- get rid of m_all, use a set instead for tokens, this allows to disable/enable tokens depending on the language mode

git-svn-id: trunk@22506 -

compiler/globals.pas

@@ -49,29 +49,29 @@ interface
 
     const
        delphimodeswitches =
-         [m_delphi,m_all,m_class,m_objpas,m_result,m_string_pchar,
+         [m_delphi,m_class,m_objpas,m_result,m_string_pchar,
           m_pointer_2_procedure,m_autoderef,m_tp_procvar,m_initfinal,m_default_ansistring,
           m_out,m_default_para,m_duplicate_names,m_hintdirective,
           m_property,m_default_inline,m_except,m_advanced_records];
        delphiunicodemodeswitches = delphimodeswitches + [m_systemcodepage,m_default_unicodestring];
        fpcmodeswitches =
-         [m_fpc,m_all,m_string_pchar,m_nested_comment,m_repeat_forward,
+         [m_fpc,m_string_pchar,m_nested_comment,m_repeat_forward,
           m_cvar_support,m_initfinal,m_hintdirective,
           m_property,m_default_inline];
        objfpcmodeswitches =
-         [m_objfpc,m_fpc,m_all,m_class,m_objpas,m_result,m_string_pchar,m_nested_comment,
+         [m_objfpc,m_fpc,m_class,m_objpas,m_result,m_string_pchar,m_nested_comment,
           m_repeat_forward,m_cvar_support,m_initfinal,m_out,m_default_para,m_hintdirective,
           m_property,m_default_inline,m_except];
        tpmodeswitches =
-         [m_tp7,m_all,m_tp_procvar,m_duplicate_names];
+         [m_tp7,m_tp_procvar,m_duplicate_names];
 {$ifdef gpc_mode}
        gpcmodeswitches =
-         [m_gpc,m_all,m_tp_procvar];
+         [m_gpc,m_tp_procvar];
 {$endif}
        macmodeswitches =
-         [m_mac,m_all,m_cvar_support,m_mac_procvar,m_nested_procvars,m_non_local_goto,m_isolike_unary_minus,m_default_inline];
+         [m_mac,m_cvar_support,m_mac_procvar,m_nested_procvars,m_non_local_goto,m_isolike_unary_minus,m_default_inline];
        isomodeswitches =
-         [m_iso,m_all,m_tp_procvar,m_duplicate_names,m_nested_procvars,m_non_local_goto,m_isolike_unary_minus];
+         [m_iso,m_tp_procvar,m_duplicate_names,m_nested_procvars,m_non_local_goto,m_isolike_unary_minus];
 
        { maximum nesting of routines }
        maxnesting = 32;

compiler/globtype.pas

@@ -311,7 +311,7 @@ interface
 
     type
        { Switches which can be changed by a mode (fpc,tp7,delphi) }
-       tmodeswitch = (m_none,m_all, { needed for keyword }
+       tmodeswitch = (m_none,
          { generic }
          m_fpc,m_objfpc,m_delphi,m_tp7,m_mac,m_iso,
          {$ifdef fpc_mode}m_gpc,{$endif}
@@ -352,6 +352,10 @@ interface
        );
        tmodeswitches = set of tmodeswitch;
 
+    const
+       alllanguagemodes = [m_fpc,m_objfpc,m_delphi,m_tp7,m_mac,m_iso];
+
+    type
        { Win32, OS/2 & MacOS application types }
        tapptype = (
          app_none,
@@ -473,7 +477,7 @@ interface
 
        cstylearrayofconst = [pocall_cdecl,pocall_cppdecl,pocall_mwpascal];
 
-       modeswitchstr : array[tmodeswitch] of string[18] = ('','',
+       modeswitchstr : array[tmodeswitch] of string[18] = ('',
          '','','','','','',
          {$ifdef fpc_mode}'',{$endif}
          { more specific }

compiler/pbase.pas

@@ -113,7 +113,7 @@ implementation
            if we just parsed the a token that has m_class }
          if not(m_class in current_settings.modeswitches) and
             (Upper(s)=pattern) and
-            (tokeninfo^[idtoken].keyword=m_class) then
+            (m_class in tokeninfo^[idtoken].keyword) then
            Message(parser_f_need_objfpc_or_delphi_mode);
        end;
 

compiler/psub.pas

@@ -1779,7 +1779,7 @@ implementation
       }
 
       var
-        oldfailtokenmode : tmodeswitch;
+        oldfailtokenmode : tmodeswitches;
         isnestedproc     : boolean;
       begin
         Message1(parser_d_procedure_start,pd.fullprocname(false));
@@ -1814,7 +1814,7 @@ implementation
         if (pd.proctypeoption=potype_constructor) then
          begin
            oldfailtokenmode:=tokeninfo^[_FAIL].keyword;
-           tokeninfo^[_FAIL].keyword:=m_all;
+           tokeninfo^[_FAIL].keyword:=alllanguagemodes;
          end;
 
         tcgprocinfo(current_procinfo).parse_body;

compiler/scanner.pas

@@ -315,7 +315,7 @@ implementation
             low:=mid;
          end;
         is_keyword:=(pattern=tokeninfo^[ttoken(high)].str) and
-                    (tokeninfo^[ttoken(high)].keyword in current_settings.modeswitches);
+                    ((tokeninfo^[ttoken(high)].keyword*current_settings.modeswitches)<>[]);
       end;
 
 
@@ -324,7 +324,7 @@ implementation
         { turn ansi/unicodestrings on by default ? (only change when this
           particular setting is changed, so that a random modeswitch won't
           change the state of $h+/$h-) }
-        if switch in [m_all,m_default_ansistring,m_default_unicodestring] then
+        if switch in [m_none,m_default_ansistring,m_default_unicodestring] then
           begin
             if ([m_default_ansistring,m_default_unicodestring]*current_settings.modeswitches)<>[] then
               begin
@@ -355,7 +355,7 @@ implementation
           end;
 
         { turn inline on by default ? }
-        if switch in [m_all,m_default_inline] then
+        if switch in [m_none,m_default_inline] then
           begin
             if (m_default_inline in current_settings.modeswitches) then
              begin
@@ -372,7 +372,7 @@ implementation
           end;
 
         { turn on system codepage by default }
-        if switch in [m_all,m_systemcodepage] then
+        if switch in [m_none,m_systemcodepage] then
           begin
             if m_systemcodepage in current_settings.modeswitches then
               begin
@@ -455,7 +455,7 @@ implementation
            { resolve all postponed switch changes }
            flushpendingswitchesstate;
 
-           HandleModeSwitches(m_all,changeinit);
+           HandleModeSwitches(m_none,changeinit);
 
            { turn on bitpacking for mode macpas and iso pascal }
            if ([m_mac,m_iso] * current_settings.modeswitches <> []) then
@@ -3961,7 +3961,7 @@ In case not, the value returned can be arbitrary.
               with tokeninfo^[ttoken(high)] do
                 if pattern=str then
                   begin
-                    if keyword in current_settings.modeswitches then
+                    if (keyword*current_settings.modeswitches)<>[] then
                       if op=NOTOKEN then
                         token:=ttoken(high)
                       else

compiler/tokens.pas

@@ -309,7 +309,7 @@ type
   tokenrec=record
     str     : string[tokenlenmax];
     special : boolean;
-    keyword : tmodeswitch;
+    keyword : tmodeswitches;
     op      : ttoken;
   end;
 
@@ -325,271 +325,271 @@ type
 
 const
   arraytokeninfo : ttokenarray =(
-      (str:''              ;special:true ;keyword:m_none;op:NOTOKEN),
+      (str:''              ;special:true ;keyword:[m_none];op:NOTOKEN),
     { Operators which can be overloaded }
-      (str:'+'             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'-'             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'*'             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'/'             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'='             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'>'             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'<'             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'>='            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'<='            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'<>'            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'><'            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'**'            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'as'            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'in'            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'is'            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'or'            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'and'           ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'div'           ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'mod'           ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'not'           ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'shl'           ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'shr'           ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'xor'           ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:':='            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'explicit'      ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'enumerator'    ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'inc'           ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'dec'           ;special:true ;keyword:m_none;op:NOTOKEN),
+      (str:'+'             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'-'             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'*'             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'/'             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'='             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'>'             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'<'             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'>='            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'<='            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'<>'            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'><'            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'**'            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'as'            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'in'            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'is'            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'or'            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'and'           ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'div'           ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'mod'           ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'not'           ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'shl'           ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'shr'           ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'xor'           ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:':='            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'explicit'      ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'enumerator'    ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'inc'           ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'dec'           ;special:true ;keyword:[m_none];op:NOTOKEN),
     { Special chars }
-      (str:'^'             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'['             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:']'             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'.'             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:','             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'('             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:')'             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:':'             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:';'             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'@'             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'..'            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'...'           ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'|'             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'&'             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'end of file'   ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'identifier'    ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'non identifier';special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'const real'    ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'ordinal const' ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'const string'  ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'const char'    ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'const wstring' ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'const wchar'   ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'<'             ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'>'             ;special:true ;keyword:m_none;op:NOTOKEN),
+      (str:'^'             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'['             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:']'             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'.'             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:','             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'('             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:')'             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:':'             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:';'             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'@'             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'..'            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'...'           ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'|'             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'&'             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'end of file'   ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'identifier'    ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'non identifier';special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'const real'    ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'ordinal const' ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'const string'  ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'const char'    ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'const wstring' ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'const wchar'   ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'<'             ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'>'             ;special:true ;keyword:[m_none];op:NOTOKEN),
     { C like operators }
-      (str:'+='            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'-='            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'&='            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'|='            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'*='            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'/='            ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:''              ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:''              ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:''              ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:''              ;special:true ;keyword:m_none;op:NOTOKEN),
-      (str:'gen. spec.'    ;special:true ;keyword:m_none;op:NOTOKEN),
+      (str:'+='            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'-='            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'&='            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'|='            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'*='            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'/='            ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:''              ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:''              ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:''              ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:''              ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'gen. spec.'    ;special:true ;keyword:[m_none];op:NOTOKEN),
     { 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),
-      (str:'AS'            ;special:false;keyword:m_class;op:_OP_AS),
-      (str:'AT'            ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'DO'            ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'IF'            ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'IN'            ;special:false;keyword:m_all;op:_OP_IN),
-      (str:'IS'            ;special:false;keyword:m_class;op:_OP_IS),
-      (str:'OF'            ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'ON'            ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'OR'            ;special:false;keyword:m_all;op:_OP_OR),
-      (str:'TO'            ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'ADD'           ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'AND'           ;special:false;keyword:m_all;op:_OP_AND),
-      (str:'ASM'           ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'DEC'           ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'DIV'           ;special:false;keyword:m_all;op:_OP_DIV),
-      (str:'END'           ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'FAR'           ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'FOR'           ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'INC'           ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'MOD'           ;special:false;keyword:m_all;op:_OP_MOD),
-      (str:'NIL'           ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'NOT'           ;special:false;keyword:m_all;op:_OP_NOT),
-      (str:'OUT'           ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'SET'           ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'SHL'           ;special:false;keyword:m_all;op:_OP_SHL),
-      (str:'SHR'           ;special:false;keyword:m_all;op:_OP_SHR),
-      (str:'TRY'           ;special:false;keyword:m_except;op:NOTOKEN),
-      (str:'VAR'           ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'XOR'           ;special:false;keyword:m_all;op:_OP_XOR),
-      (str:'CASE'          ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'CVAR'          ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'ELSE'          ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'EXIT'          ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'FAIL'          ;special:false;keyword:m_none;op:NOTOKEN), { only set within constructors PM }
-      (str:'FILE'          ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'GOTO'          ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'NAME'          ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'NEAR'          ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'READ'          ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'SELF'          ;special:false;keyword:m_none;op:NOTOKEN), {set inside methods only PM }
-      (str:'SYSV'          ;special:false;keyword:m_none;op:NOTOKEN),   { Syscall variation on MorphOS }
-      (str:'THEN'          ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'TRUE'          ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'TYPE'          ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'UNIT'          ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'UNIV'          ;special:false;keyword:m_mac;op:NOTOKEN),
-      (str:'USES'          ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'WITH'          ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'ALIAS'         ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'ARRAY'         ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'BEGIN'         ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'BREAK'         ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'CDECL'         ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'CLASS'         ;special:false;keyword:m_class;op:NOTOKEN),
-      (str:'CONST'         ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'EQUAL'         ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'FALSE'         ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'FAR16'         ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'FINAL'         ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'INDEX'         ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'LABEL'         ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'LOCAL'         ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'RAISE'         ;special:false;keyword:m_except;op:NOTOKEN),
-      (str:'UNTIL'         ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'WHILE'         ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'WRITE'         ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'DISPID'        ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'DIVIDE'        ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'DOWNTO'        ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'EXCEPT'        ;special:false;keyword:m_except;op:NOTOKEN),
-      (str:'EXPORT'        ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'HELPER'        ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'INLINE'        ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'LEGACY'        ;special:false;keyword:m_none;op:NOTOKEN),   { Syscall variation on MorphOS }
-      (str:'NESTED'        ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'OBJECT'        ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'PACKED'        ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'PASCAL'        ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'PUBLIC'        ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'RECORD'        ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'REPEAT'        ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'RESULT'        ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'RETURN'        ;special:false;keyword:m_mac;op:NOTOKEN),
-      (str:'SEALED'        ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'STATIC'        ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'STORED'        ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'STRICT'        ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'STRING'        ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'SYSTEM'        ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'ASMNAME'       ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'CPPDECL'       ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'DEFAULT'       ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'DYNAMIC'       ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'EXPORTS'       ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'FINALLY'       ;special:false;keyword:m_except;op:NOTOKEN),
-      (str:'FORWARD'       ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'GENERIC'       ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'IOCHECK'       ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'LIBRARY'       ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'MESSAGE'       ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'MODULUS'       ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'PACKAGE'       ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'PRIVATE'       ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'PROGRAM'       ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'R12BASE'       ;special:false;keyword:m_none;op:NOTOKEN),   { Syscall variation on MorphOS }
-      (str:'RTLPROC'       ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'SECTION'       ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'STDCALL'       ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'SYSCALL'       ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'VARARGS'       ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'VIRTUAL'       ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'ABSOLUTE'      ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'ABSTRACT'      ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'BASESYSV'      ;special:false;keyword:m_none;op:NOTOKEN),   { Syscall variation on MorphOS }
-      (str:'CONSTREF'      ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'CONTAINS'      ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'CONTINUE'      ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'CPPCLASS'      ;special:false;keyword:m_fpc;op:NOTOKEN),
-      (str:'EXPLICIT'      ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'EXTERNAL'      ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'FUNCTION'      ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'IMPLICIT'      ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'LESSTHAN'      ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'LOCATION'      ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'MULTIPLY'      ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'MWPASCAL'      ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'NEGATIVE'      ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'NOTEQUAL'      ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'OPERATOR'      ;special:false;keyword:m_fpc;op:NOTOKEN),
-      (str:'OPTIONAL'      ;special:false;keyword:m_none;op:NOTOKEN), { optional methods in an Objective-C protocol }
-      (str:'OVERLOAD'      ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'OVERRIDE'      ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'PLATFORM'      ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'POSITIVE'      ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'PROPERTY'      ;special:false;keyword:m_property;op:NOTOKEN),
-      (str:'READONLY'      ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'REGISTER'      ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'REQUIRED'      ;special:false;keyword:m_none;op:NOTOKEN), { required methods in an Objective-C protocol }
-      (str:'REQUIRES'      ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'RESIDENT'      ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'SAFECALL'      ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'SUBTRACT'      ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'SYSVBASE'      ;special:false;keyword:m_none;op:NOTOKEN),   { Syscall variation on MorphOS }
-      (str:'ASSEMBLER'     ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'BITPACKED'     ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'BITWISEOR'     ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'INHERITED'     ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'INTDIVIDE'     ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'INTERFACE'     ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'INTERRUPT'     ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'LEFTSHIFT'     ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'LOGICALOR'     ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'NODEFAULT'     ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'OBJCCLASS'     ;special:false;keyword:m_objectivec1;op:NOTOKEN),
-      (str:'OTHERWISE'     ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'PROCEDURE'     ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'PROTECTED'     ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'PUBLISHED'     ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'SOFTFLOAT'     ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'THREADVAR'     ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'WRITEONLY'     ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'BITWISEAND'    ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'BITWISEXOR'    ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'DEPRECATED'    ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'DESTRUCTOR'    ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'ENUMERATOR'    ;special:false;keyword:m_none;op:_OP_ENUMERATOR),
-      (str:'IMPLEMENTS'    ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'INTERNPROC'    ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'LOGICALAND'    ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'LOGICALNOT'    ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'LOGICALXOR'    ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'OLDFPCCALL'    ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'OPENSTRING'    ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'RIGHTSHIFT'    ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'SPECIALIZE'    ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'CONSTRUCTOR'   ;special:false;keyword:m_all;op:NOTOKEN),
-      (str:'GREATERTHAN'   ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }
-      (str:'INTERNCONST'   ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'REINTRODUCE'   ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'SHORTSTRING'   ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'COMPILERPROC'  ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'EXPERIMENTAL'  ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'FINALIZATION'  ;special:false;keyword:m_initfinal;op:NOTOKEN),
-      (str:'NOSTACKFRAME'  ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'OBJCCATEGORY'  ;special:false;keyword:m_objectivec1;op:NOTOKEN), { Objective-C category }
-      (str:'OBJCPROTOCOL'  ;special:false;keyword:m_objectivec1;op:NOTOKEN), { Objective-C protocol }
-      (str:'WEAKEXTERNAL'  ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'DISPINTERFACE' ;special:false;keyword:m_class;op:NOTOKEN),
-      (str:'UNIMPLEMENTED' ;special:false;keyword:m_none;op:NOTOKEN),
-      (str:'IMPLEMENTATION';special:false;keyword:m_all;op:NOTOKEN),
-      (str:'INITIALIZATION';special:false;keyword:m_initfinal;op:NOTOKEN),
-      (str:'RESOURCESTRING';special:false;keyword:m_all;op:NOTOKEN),
-      (str:'LESSTHANOREQUAL';special:false;keyword:m_none;op:NOTOKEN),    { delphi operator name }
-      (str:'GREATERTHANOREQUAL';special:false;keyword:m_none;op:NOTOKEN)  { delphi operator name }
+      (str:'C'             ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'AS'            ;special:false;keyword:[m_class];op:_OP_AS),
+      (str:'AT'            ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'DO'            ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'IF'            ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'IN'            ;special:false;keyword:alllanguagemodes;op:_OP_IN),
+      (str:'IS'            ;special:false;keyword:[m_class];op:_OP_IS),
+      (str:'OF'            ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'ON'            ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'OR'            ;special:false;keyword:alllanguagemodes;op:_OP_OR),
+      (str:'TO'            ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'ADD'           ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'AND'           ;special:false;keyword:alllanguagemodes;op:_OP_AND),
+      (str:'ASM'           ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'DEC'           ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'DIV'           ;special:false;keyword:alllanguagemodes;op:_OP_DIV),
+      (str:'END'           ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'FAR'           ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'FOR'           ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'INC'           ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'MOD'           ;special:false;keyword:alllanguagemodes;op:_OP_MOD),
+      (str:'NIL'           ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'NOT'           ;special:false;keyword:alllanguagemodes;op:_OP_NOT),
+      (str:'OUT'           ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'SET'           ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'SHL'           ;special:false;keyword:alllanguagemodes;op:_OP_SHL),
+      (str:'SHR'           ;special:false;keyword:alllanguagemodes;op:_OP_SHR),
+      (str:'TRY'           ;special:false;keyword:[m_except];op:NOTOKEN),
+      (str:'VAR'           ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'XOR'           ;special:false;keyword:alllanguagemodes;op:_OP_XOR),
+      (str:'CASE'          ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'CVAR'          ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'ELSE'          ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'EXIT'          ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'FAIL'          ;special:false;keyword:[m_none];op:NOTOKEN), { only set within constructors PM }
+      (str:'FILE'          ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'GOTO'          ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'NAME'          ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'NEAR'          ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'READ'          ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'SELF'          ;special:false;keyword:[m_none];op:NOTOKEN), {set inside methods only PM }
+      (str:'SYSV'          ;special:false;keyword:[m_none];op:NOTOKEN),   { Syscall variation on MorphOS }
+      (str:'THEN'          ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'TRUE'          ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'TYPE'          ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'UNIT'          ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'UNIV'          ;special:false;keyword:[m_mac];op:NOTOKEN),
+      (str:'USES'          ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'WITH'          ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'ALIAS'         ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'ARRAY'         ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'BEGIN'         ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'BREAK'         ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'CDECL'         ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'CLASS'         ;special:false;keyword:[m_class];op:NOTOKEN),
+      (str:'CONST'         ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'EQUAL'         ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'FALSE'         ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'FAR16'         ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'FINAL'         ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'INDEX'         ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'LABEL'         ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'LOCAL'         ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'RAISE'         ;special:false;keyword:[m_except];op:NOTOKEN),
+      (str:'UNTIL'         ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'WHILE'         ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'WRITE'         ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'DISPID'        ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'DIVIDE'        ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'DOWNTO'        ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'EXCEPT'        ;special:false;keyword:[m_except];op:NOTOKEN),
+      (str:'EXPORT'        ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'HELPER'        ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'INLINE'        ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'LEGACY'        ;special:false;keyword:[m_none];op:NOTOKEN),   { Syscall variation on MorphOS }
+      (str:'NESTED'        ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'OBJECT'        ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'PACKED'        ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'PASCAL'        ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'PUBLIC'        ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'RECORD'        ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'REPEAT'        ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'RESULT'        ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'RETURN'        ;special:false;keyword:[m_mac];op:NOTOKEN),
+      (str:'SEALED'        ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'STATIC'        ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'STORED'        ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'STRICT'        ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'STRING'        ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'SYSTEM'        ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'ASMNAME'       ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'CPPDECL'       ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'DEFAULT'       ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'DYNAMIC'       ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'EXPORTS'       ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'FINALLY'       ;special:false;keyword:[m_except];op:NOTOKEN),
+      (str:'FORWARD'       ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'GENERIC'       ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'IOCHECK'       ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'LIBRARY'       ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'MESSAGE'       ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'MODULUS'       ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'PACKAGE'       ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'PRIVATE'       ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'PROGRAM'       ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'R12BASE'       ;special:false;keyword:[m_none];op:NOTOKEN),   { Syscall variation on MorphOS }
+      (str:'RTLPROC'       ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'SECTION'       ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'STDCALL'       ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'SYSCALL'       ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'VARARGS'       ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'VIRTUAL'       ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'ABSOLUTE'      ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'ABSTRACT'      ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'BASESYSV'      ;special:false;keyword:[m_none];op:NOTOKEN),   { Syscall variation on MorphOS }
+      (str:'CONSTREF'      ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'CONTAINS'      ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'CONTINUE'      ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'CPPCLASS'      ;special:false;keyword:[m_fpc];op:NOTOKEN),
+      (str:'EXPLICIT'      ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'EXTERNAL'      ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'FUNCTION'      ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'IMPLICIT'      ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'LESSTHAN'      ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'LOCATION'      ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'MULTIPLY'      ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'MWPASCAL'      ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'NEGATIVE'      ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'NOTEQUAL'      ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'OPERATOR'      ;special:false;keyword:[m_fpc];op:NOTOKEN),
+      (str:'OPTIONAL'      ;special:false;keyword:[m_none];op:NOTOKEN), { optional methods in an Objective-C protocol }
+      (str:'OVERLOAD'      ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'OVERRIDE'      ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'PLATFORM'      ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'POSITIVE'      ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'PROPERTY'      ;special:false;keyword:[m_property];op:NOTOKEN),
+      (str:'READONLY'      ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'REGISTER'      ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'REQUIRED'      ;special:false;keyword:[m_none];op:NOTOKEN), { required methods in an Objective-C protocol }
+      (str:'REQUIRES'      ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'RESIDENT'      ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'SAFECALL'      ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'SUBTRACT'      ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'SYSVBASE'      ;special:false;keyword:[m_none];op:NOTOKEN),   { Syscall variation on MorphOS }
+      (str:'ASSEMBLER'     ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'BITPACKED'     ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'BITWISEOR'     ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'INHERITED'     ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'INTDIVIDE'     ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'INTERFACE'     ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'INTERRUPT'     ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'LEFTSHIFT'     ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'LOGICALOR'     ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'NODEFAULT'     ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'OBJCCLASS'     ;special:false;keyword:[m_objectivec1];op:NOTOKEN),
+      (str:'OTHERWISE'     ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'PROCEDURE'     ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'PROTECTED'     ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'PUBLISHED'     ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'SOFTFLOAT'     ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'THREADVAR'     ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'WRITEONLY'     ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'BITWISEAND'    ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'BITWISEXOR'    ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'DEPRECATED'    ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'DESTRUCTOR'    ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'ENUMERATOR'    ;special:false;keyword:[m_none];op:_OP_ENUMERATOR),
+      (str:'IMPLEMENTS'    ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'INTERNPROC'    ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'LOGICALAND'    ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'LOGICALNOT'    ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'LOGICALXOR'    ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'OLDFPCCALL'    ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'OPENSTRING'    ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'RIGHTSHIFT'    ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'SPECIALIZE'    ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'CONSTRUCTOR'   ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'GREATERTHAN'   ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
+      (str:'INTERNCONST'   ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'REINTRODUCE'   ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'SHORTSTRING'   ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'COMPILERPROC'  ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'EXPERIMENTAL'  ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'FINALIZATION'  ;special:false;keyword:[m_initfinal];op:NOTOKEN),
+      (str:'NOSTACKFRAME'  ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'OBJCCATEGORY'  ;special:false;keyword:[m_objectivec1];op:NOTOKEN), { Objective-C category }
+      (str:'OBJCPROTOCOL'  ;special:false;keyword:[m_objectivec1];op:NOTOKEN), { Objective-C protocol }
+      (str:'WEAKEXTERNAL'  ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'DISPINTERFACE' ;special:false;keyword:[m_class];op:NOTOKEN),
+      (str:'UNIMPLEMENTED' ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'IMPLEMENTATION';special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'INITIALIZATION';special:false;keyword:[m_initfinal];op:NOTOKEN),
+      (str:'RESOURCESTRING';special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'LESSTHANOREQUAL';special:false;keyword:[m_none];op:NOTOKEN),    { delphi operator name }
+      (str:'GREATERTHANOREQUAL';special:false;keyword:[m_none];op:NOTOKEN)  { delphi operator name }
   );