+ one field added for ttoken record for operator

    linking the id to the corresponding operator token that
    can now now all be overloaded
  * overloaded operators are resetted to nil in InitSymtable
    (bug when trying to compile a uint that overloads operators twice)

compiler/pexpr.pas

@@ -1916,23 +1916,25 @@ _LECKKLAMMER : begin
         (tok:_LTE     ;nod:lten),
         (tok:_SYMDIF  ;nod:symdifn),
         (tok:_STARSTAR;nod:starstarn),
+        (tok:_OP_AS     ;nod:asn),
+        (tok:_OP_IN     ;nod:inn),
+        (tok:_OP_IS     ;nod:isn),
+        (tok:_OP_OR     ;nod:orn),
+        (tok:_OP_AND    ;nod:andn),
+        (tok:_OP_DIV    ;nod:divn),
+        (tok:_OP_MOD    ;nod:modn),
+        (tok:_OP_SHL    ;nod:shln),
+        (tok:_OP_SHR    ;nod:shrn),
+        (tok:_OP_XOR    ;nod:xorn),
         (tok:_CARET   ;nod:caretn),
-        (tok:_UNEQUAL ;nod:unequaln),
-        (tok:_AS     ;nod:asn),
-        (tok:_IN     ;nod:inn),
-        (tok:_IS     ;nod:isn),
-        (tok:_OR     ;nod:orn),
-        (tok:_AND    ;nod:andn),
-        (tok:_DIV    ;nod:divn),
-        (tok:_MOD    ;nod:modn),
-        (tok:_SHL    ;nod:shln),
-        (tok:_SHR    ;nod:shrn),
-        (tok:_XOR    ;nod:xorn)
+        (tok:_UNEQUAL ;nod:unequaln)
       );
+      { Warning these stay be ordered !! }
       operator_levels:array[Toperator_precedence] of set of Ttoken=
-         ([_LT,_LTE,_GT,_GTE,_EQUAL,_UNEQUAL,_IN,_IS],
-          [_PLUS,_MINUS,_OR,_XOR],
-          [_CARET,_SYMDIF,_STARSTAR,_STAR,_SLASH,_DIV,_MOD,_AND,_SHL,_SHR,_AS]);
+         ([_LT,_LTE,_GT,_GTE,_EQUAL,_UNEQUAL,_OP_IN,_OP_IS],
+          [_PLUS,_MINUS,_OP_OR,_OP_XOR],
+          [_CARET,_SYMDIF,_STARSTAR,_STAR,_SLASH,
+           _OP_AS,_OP_AND,_OP_DIV,_OP_MOD,_OP_SHL,_OP_SHR]);
 
     function sub_expr(pred_level:Toperator_precedence;accept_equal : boolean):Ptree;
     {Reads a subexpression while the operators are of the current precedence
@@ -2114,7 +2116,14 @@ _LECKKLAMMER : begin
 end.
 {
   $Log$
-  Revision 1.158  1999-11-14 15:57:35  peter
+  Revision 1.159  1999-11-15 17:52:59  pierre
+    + one field added for ttoken record for operator
+      linking the id to the corresponding operator token that
+      can now now all be overloaded
+    * overloaded operators are resetted to nil in InitSymtable
+      (bug when trying to compile a uint that overloads operators twice)
+
+  Revision 1.158  1999/11/14 15:57:35  peter
     * fixed crash with an errordef
 
   Revision 1.157  1999/11/08 14:02:16  florian

compiler/scanner.pas

@@ -1108,7 +1108,10 @@ implementation
               if pattern=tokeninfo^[ttoken(high)].str then
                begin
                  if tokeninfo^[ttoken(high)].keyword in aktmodeswitches then
-                  token:=ttoken(high);
+                  if tokeninfo^[ttoken(high)].op=NOTOKEN then
+                    token:=ttoken(high)
+                  else
+                    token:=tokeninfo^[ttoken(high)].op;
                  idtoken:=ttoken(high);
                end;
             end;
@@ -1511,7 +1514,7 @@ implementation
                    '>' :
                      begin
                        readchar;
-                       token:=_SHR;
+                       token:=_OP_SHR;
                        goto exit_label;
                      end;
                    '<' :
@@ -1544,7 +1547,7 @@ implementation
                    '<' :
                      begin
                        readchar;
-                       token:=_SHL;
+                       token:=_OP_SHL;
                        goto exit_label;
                      end;
                  end;
@@ -1695,7 +1698,14 @@ exit_label:
 end.
 {
   $Log$
-  Revision 1.100  1999-11-06 14:34:26  peter
+  Revision 1.101  1999-11-15 17:52:59  pierre
+    + one field added for ttoken record for operator
+      linking the id to the corresponding operator token that
+      can now now all be overloaded
+    * overloaded operators are resetted to nil in InitSymtable
+      (bug when trying to compile a uint that overloads operators twice)
+
+  Revision 1.100  1999/11/06 14:34:26  peter
     * truncated log to 20 revs
 
   Revision 1.99  1999/11/03 23:44:28  peter

compiler/symtable.pas

@@ -362,8 +362,11 @@ unit symtable;
        overloaded_names : array [first_overloaded..last_overloaded] of string[16] =
          ('plus','minus','star','slash','equal',
           'greater','lower','greater_or_equal',
-          'lower_or_equal','as','is','in','sym_diff',
-          'starstar','assign');
+          'lower_or_equal',
+          'sym_diff','starstar',
+          'as','is','in','or',
+          'and','div','mod','shl','shr','xor',
+          'assign');
 
 {$ifdef UNITALIASES}
     type
@@ -2460,6 +2463,8 @@ implementation
      { unit aliases }
         unitaliases:=new(pdictionary,init);
 {$endif}
+       for token:=first_overloaded to last_overloaded do
+         overloaded_operators[token]:=nil;
      end;
 
 
@@ -2482,7 +2487,14 @@ implementation
 end.
 {
   $Log$
-  Revision 1.60  1999-11-09 23:35:50  pierre
+  Revision 1.61  1999-11-15 17:52:59  pierre
+    + one field added for ttoken record for operator
+      linking the id to the corresponding operator token that
+      can now now all be overloaded
+    * overloaded operators are resetted to nil in InitSymtable
+      (bug when trying to compile a uint that overloads operators twice)
+
+  Revision 1.60  1999/11/09 23:35:50  pierre
    + better reference pos for forward defs
 
   Revision 1.59  1999/11/06 16:21:57  jonas

compiler/tcadd.pas

@@ -73,6 +73,7 @@ implementation
          resdef,
          rd,ld   : pdef;
          tempdef : pdef;
+         optoken : ttoken;
          concatstrings : boolean;
 
          { to evalute const sets }
@@ -142,27 +143,44 @@ implementation
                  { the nil as symtable signs firstcalln that this is
                    an overloaded operator }
                  addn:
-                   t:=gencallnode(overloaded_operators[_plus],nil);
+                   token:=_PLUS;
                  subn:
-                   t:=gencallnode(overloaded_operators[_minus],nil);
+                   token:=_MINUS;
                  muln:
-                   t:=gencallnode(overloaded_operators[_star],nil);
+                   token:=_STAR;
                  starstarn:
-                   t:=gencallnode(overloaded_operators[_starstar],nil);
+                   token:=_STARSTAR;
                  slashn:
-                   t:=gencallnode(overloaded_operators[_slash],nil);
+                   token:=_SLASH;
                  ltn:
-                   t:=gencallnode(overloaded_operators[tokens._lt],nil);
+                   token:=tokens._lt;
                  gtn:
-                   t:=gencallnode(overloaded_operators[_gt],nil);
+                   token:=tokens._gt;
                  lten:
-                   t:=gencallnode(overloaded_operators[_lte],nil);
+                   token:=_lte;
                  gten:
-                   t:=gencallnode(overloaded_operators[_gte],nil);
+                   token:=_gte;
                  equaln,unequaln :
-                   t:=gencallnode(overloaded_operators[_equal],nil);
+                   token:=_EQUAL;
+                 symdifn :
+                   token:=_SYMDIF;
+                 modn :
+                   token:=_OP_MOD;
+                 orn :
+                   token:=_OP_OR;
+                 xorn :
+                   token:=_OP_XOR;
+                 andn :
+                   token:=_OP_AND;
+                 divn :
+                   token:=_OP_DIV;
+                 shln :
+                   token:=_OP_SHL;
+                 shrn :
+                   token:=_OP_SHR;
                  else goto no_overload;
               end;
+              t:=gencallnode(overloaded_operators[token],nil);
               { we have to convert p^.left and p^.right into
                callparanodes }
               if t^.symtableprocentry=nil then
@@ -1136,7 +1154,14 @@ implementation
 end.
 {
   $Log$
-  Revision 1.51  1999-11-06 14:34:29  peter
+  Revision 1.52  1999-11-15 17:53:00  pierre
+    + one field added for ttoken record for operator
+      linking the id to the corresponding operator token that
+      can now now all be overloaded
+    * overloaded operators are resetted to nil in InitSymtable
+      (bug when trying to compile a uint that overloads operators twice)
+
+  Revision 1.51  1999/11/06 14:34:29  peter
     * truncated log to 20 revs
 
   Revision 1.50  1999/09/27 23:45:00  peter

compiler/tokens.pas

@@ -43,9 +43,16 @@ type
     _LTE,
     _SYMDIF,
     _STARSTAR,
-    _OP_IS,
     _OP_AS,
     _OP_IN,
+    _OP_IS,
+    _OP_OR,
+    _OP_AND,
+    _OP_DIV,
+    _OP_MOD,
+    _OP_SHL,
+    _OP_SHR,
+    _OP_XOR,
     _ASSIGNMENT,
     { special chars }
     _CARET,
@@ -206,6 +213,7 @@ type
     str     : string[tokenidlen];
     special : boolean;
     keyword : tmodeswitch;
+    op      : ttoken;
     encoded : longint;
   end;
 
@@ -221,176 +229,183 @@ type
 
 const
   arraytokeninfo : ttokenarray =(
-      (str:''              ;special:true ;keyword:m_none),
+      (str:''              ;special:true ;keyword:m_none;op:NOTOKEN),
     { Operators which can be overloaded }
-      (str:'+'             ;special:true ;keyword:m_none),
-      (str:'-'             ;special:true ;keyword:m_none),
-      (str:'*'             ;special:true ;keyword:m_none),
-      (str:'/'             ;special:true ;keyword:m_none),
-      (str:'='             ;special:true ;keyword:m_none),
-      (str:'>'             ;special:true ;keyword:m_none),
-      (str:'<'             ;special:true ;keyword:m_none),
-      (str:'>='            ;special:true ;keyword:m_none),
-      (str:'<='            ;special:true ;keyword:m_none),
-      (str:'><'            ;special:true ;keyword:m_none),
-      (str:'**'            ;special:true ;keyword:m_none),
-      (str:'is'            ;special:true ;keyword:m_none),
-      (str:'as'            ;special:true ;keyword:m_none),
-      (str:'in'            ;special:true ;keyword:m_none),
-      (str:':='            ;special:true ;keyword:m_none),
+      (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:'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),
     { Special chars }
-      (str:'^'             ;special:true ;keyword:m_none),
-      (str:'<>'            ;special:true ;keyword:m_none),
-      (str:'['             ;special:true ;keyword:m_none),
-      (str:']'             ;special:true ;keyword:m_none),
-      (str:'.'             ;special:true ;keyword:m_none),
-      (str:','             ;special:true ;keyword:m_none),
-      (str:'('             ;special:true ;keyword:m_none),
-      (str:')'             ;special:true ;keyword:m_none),
-      (str:':'             ;special:true ;keyword:m_none),
-      (str:';'             ;special:true ;keyword:m_none),
-      (str:'@'             ;special:true ;keyword:m_none),
-      (str:'..'            ;special:true ;keyword:m_none),
-      (str:'@@'            ;special:true ;keyword:m_none),
-      (str:'end of file'   ;special:true ;keyword:m_none),
-      (str:'identifier'    ;special:true ;keyword:m_none),
-      (str:'non identifier';special:true ;keyword:m_none),
-      (str:'const real'    ;special:true ;keyword:m_none),
-      (str:'ordinal const' ;special:true ;keyword:m_none),
-      (str:'const string'  ;special:true ;keyword:m_none),
-      (str:'const char'    ;special:true ;keyword:m_none),
+      (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),
     { C like operators }
-      (str:'+='            ;special:true ;keyword:m_none),
-      (str:'-='            ;special:true ;keyword:m_none),
-      (str:'&='            ;special:true ;keyword:m_none),
-      (str:'|='            ;special:true ;keyword:m_none),
-      (str:'*='            ;special:true ;keyword:m_none),
-      (str:'/='            ;special:true ;keyword:m_none),
-      (str:''              ;special:true ;keyword:m_none),
-      (str:''              ;special:true ;keyword:m_none),
-      (str:''              ;special:true ;keyword:m_none),
-      (str:''              ;special:true ;keyword:m_none),
+      (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),
     { Normal words }
-      (str:'AS'            ;special:false;keyword:m_class),
-      (str:'AT'            ;special:false;keyword:m_none),
-      (str:'DO'            ;special:false;keyword:m_all),
-      (str:'IF'            ;special:false;keyword:m_all),
-      (str:'IN'            ;special:false;keyword:m_all),
-      (str:'IS'            ;special:false;keyword:m_class),
-      (str:'OF'            ;special:false;keyword:m_all),
-      (str:'ON'            ;special:false;keyword:m_class),
-      (str:'OR'            ;special:false;keyword:m_all),
-      (str:'TO'            ;special:false;keyword:m_all),
-      (str:'AND'           ;special:false;keyword:m_all),
-      (str:'ASM'           ;special:false;keyword:m_all),
-      (str:'DIV'           ;special:false;keyword:m_all),
-      (str:'END'           ;special:false;keyword:m_all),
-      (str:'FAR'           ;special:false;keyword:m_none),
-      (str:'FOR'           ;special:false;keyword:m_all),
-      (str:'MOD'           ;special:false;keyword:m_all),
-      (str:'NEW'           ;special:false;keyword:m_all),
-      (str:'NIL'           ;special:false;keyword:m_all),
-      (str:'NOT'           ;special:false;keyword:m_all),
-      (str:'SET'           ;special:false;keyword:m_all),
-      (str:'SHL'           ;special:false;keyword:m_all),
-      (str:'SHR'           ;special:false;keyword:m_all),
-      (str:'TRY'           ;special:false;keyword:m_class),
-      (str:'VAR'           ;special:false;keyword:m_all),
-      (str:'XOR'           ;special:false;keyword:m_all),
-      (str:'CASE'          ;special:false;keyword:m_all),
-      (str:'CVAR'          ;special:false;keyword:m_none),
-      (str:'ELSE'          ;special:false;keyword:m_all),
-      (str:'EXIT'          ;special:false;keyword:m_all),
-      (str:'FAIL'          ;special:false;keyword:m_none), { only set within constructors PM }
-      (str:'FILE'          ;special:false;keyword:m_all),
-      (str:'GOTO'          ;special:false;keyword:m_all),
-      (str:'NAME'          ;special:false;keyword:m_none),
-      (str:'NEAR'          ;special:false;keyword:m_none),
-      (str:'READ'          ;special:false;keyword:m_none),
-      (str:'SELF'          ;special:false;keyword:m_none), {set inside methods only PM }
-      (str:'THEN'          ;special:false;keyword:m_all),
-      (str:'TRUE'          ;special:false;keyword:m_all),
-      (str:'TYPE'          ;special:false;keyword:m_all),
-      (str:'UNIT'          ;special:false;keyword:m_all),
-      (str:'USES'          ;special:false;keyword:m_all),
-      (str:'WITH'          ;special:false;keyword:m_all),
-      (str:'ALIAS'         ;special:false;keyword:m_none),
-      (str:'ARRAY'         ;special:false;keyword:m_all),
-      (str:'BEGIN'         ;special:false;keyword:m_all),
-      (str:'BREAK'         ;special:false;keyword:m_none),
-      (str:'CDECL'         ;special:false;keyword:m_none),
-      (str:'CLASS'         ;special:false;keyword:m_class),
-      (str:'CONST'         ;special:false;keyword:m_all),
-      (str:'FALSE'         ;special:false;keyword:m_all),
-      (str:'INDEX'         ;special:false;keyword:m_none),
-      (str:'LABEL'         ;special:false;keyword:m_all),
-      (str:'RAISE'         ;special:false;keyword:m_class),
-      (str:'UNTIL'         ;special:false;keyword:m_all),
-      (str:'WHILE'         ;special:false;keyword:m_all),
-      (str:'WRITE'         ;special:false;keyword:m_none),
-      (str:'DOWNTO'        ;special:false;keyword:m_all),
-      (str:'EXCEPT'        ;special:false;keyword:m_class),
-      (str:'EXPORT'        ;special:false;keyword:m_none),
-      (str:'INLINE'        ;special:false;keyword:m_none),
-      (str:'OBJECT'        ;special:false;keyword:m_all),
-      (str:'PACKED'        ;special:false;keyword:m_all),
-      (str:'PASCAL'        ;special:false;keyword:m_none),
-      (str:'PUBLIC'        ;special:false;keyword:m_none),
-      (str:'RECORD'        ;special:false;keyword:m_all),
-      (str:'REPEAT'        ;special:false;keyword:m_all),
-      (str:'RESULT'        ;special:false;keyword:m_none),
-      (str:'STATIC'        ;special:false;keyword:m_none),
-      (str:'STORED'        ;special:false;keyword:m_none),
-      (str:'STRING'        ;special:false;keyword:m_all),
-      (str:'SYSTEM'        ;special:false;keyword:m_none),
-      (str:'ASMNAME'       ;special:false;keyword:m_none),
-      (str:'DEFAULT'       ;special:false;keyword:m_none),
-      (str:'DISPOSE'       ;special:false;keyword:m_all),
-      (str:'DYNAMIC'       ;special:false;keyword:m_none),
-      (str:'EXPORTS'       ;special:false;keyword:m_all),
-      (str:'FINALLY'       ;special:false;keyword:m_class),
-      (str:'FORWARD'       ;special:false;keyword:m_none),
-      (str:'IOCHECK'       ;special:false;keyword:m_none),
-      (str:'LIBRARY'       ;special:false;keyword:m_all),
-      (str:'MESSAGE'       ;special:false;keyword:m_none),
-      (str:'PRIVATE'       ;special:false;keyword:m_none),
-      (str:'PROGRAM'       ;special:false;keyword:m_all),
-      (str:'STDCALL'       ;special:false;keyword:m_none),
-      (str:'SYSCALL'       ;special:false;keyword:m_none),
-      (str:'VIRTUAL'       ;special:false;keyword:m_none),
-      (str:'ABSOLUTE'      ;special:false;keyword:m_none),
-      (str:'ABSTRACT'      ;special:false;keyword:m_none),
-      (str:'CONTINUE'      ;special:false;keyword:m_none),
-      (str:'EXTERNAL'      ;special:false;keyword:m_none),
-      (str:'FUNCTION'      ;special:false;keyword:m_all),
-      (str:'OPERATOR'      ;special:false;keyword:m_fpc),
-      (str:'OVERRIDE'      ;special:false;keyword:m_none),
-      (str:'POPSTACK'      ;special:false;keyword:m_none),
-      (str:'PROPERTY'      ;special:false;keyword:m_class),
-      (str:'REGISTER'      ;special:false;keyword:m_none),
-      (str:'RESIDENT'      ;special:false;keyword:m_none),
-      (str:'SAFECALL'      ;special:false;keyword:m_none),
-      (str:'ASSEMBLER'     ;special:false;keyword:m_none),
-      (str:'INHERITED'     ;special:false;keyword:m_all),
-      (str:'INTERFACE'     ;special:false;keyword:m_all),
-      (str:'INTERRUPT'     ;special:false;keyword:m_none),
-      (str:'NODEFAULT'     ;special:false;keyword:m_none),
-      (str:'OTHERWISE'     ;special:false;keyword:m_all),
-      (str:'PROCEDURE'     ;special:false;keyword:m_all),
-      (str:'PROTECTED'     ;special:false;keyword:m_none),
-      (str:'PUBLISHED'     ;special:false;keyword:m_none),
-      (str:'THREADVAR'     ;special:false;keyword:m_class),
-      (str:'DESTRUCTOR'    ;special:false;keyword:m_all),
-      (str:'INTERNPROC'    ;special:false;keyword:m_none),
-      (str:'OPENSTRING'    ;special:false;keyword:m_none),
-      (str:'CONSTRUCTOR'   ;special:false;keyword:m_all),
-      (str:'INTERNCONST'   ;special:false;keyword:m_none),
-      (str:'SHORTSTRING'   ;special:false;keyword:m_none),
-      (str:'FINALIZATION'  ;special:false;keyword:m_initfinal),
-      (str:'SAVEREGISTERS' ;special:false;keyword:m_none),
-      (str:'IMPLEMENTATION';special:false;keyword:m_all),
-      (str:'INITIALIZATION';special:false;keyword:m_initfinal),
-      (str:'RESOURCESTRING';special:false;keyword:m_class)
+      (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_class;op:NOTOKEN),
+      (str:'OR'            ;special:false;keyword:m_all;op:_OP_OR),
+      (str:'TO'            ;special:false;keyword:m_all;op:NOTOKEN),
+      (str:'AND'           ;special:false;keyword:m_all;op:_OP_AND),
+      (str:'ASM'           ;special:false;keyword:m_all;op:NOTOKEN),
+      (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:'MOD'           ;special:false;keyword:m_all;op:_OP_MOD),
+      (str:'NEW'           ;special:false;keyword:m_all;op:NOTOKEN),
+      (str:'NIL'           ;special:false;keyword:m_all;op:NOTOKEN),
+      (str:'NOT'           ;special:false;keyword:m_all;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_class;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_all;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:'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:'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:'FALSE'         ;special:false;keyword:m_all;op:NOTOKEN),
+      (str:'INDEX'         ;special:false;keyword:m_none;op:NOTOKEN),
+      (str:'LABEL'         ;special:false;keyword:m_all;op:NOTOKEN),
+      (str:'RAISE'         ;special:false;keyword:m_class;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:'DOWNTO'        ;special:false;keyword:m_all;op:NOTOKEN),
+      (str:'EXCEPT'        ;special:false;keyword:m_class;op:NOTOKEN),
+      (str:'EXPORT'        ;special:false;keyword:m_none;op:NOTOKEN),
+      (str:'INLINE'        ;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:'STATIC'        ;special:false;keyword:m_none;op:NOTOKEN),
+      (str:'STORED'        ;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:'DEFAULT'       ;special:false;keyword:m_none;op:NOTOKEN),
+      (str:'DISPOSE'       ;special:false;keyword:m_all;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_class;op:NOTOKEN),
+      (str:'FORWARD'       ;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:'PRIVATE'       ;special:false;keyword:m_none;op:NOTOKEN),
+      (str:'PROGRAM'       ;special:false;keyword:m_all;op:NOTOKEN),
+      (str:'STDCALL'       ;special:false;keyword:m_none;op:NOTOKEN),
+      (str:'SYSCALL'       ;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:'CONTINUE'      ;special:false;keyword:m_none;op:NOTOKEN),
+      (str:'EXTERNAL'      ;special:false;keyword:m_none;op:NOTOKEN),
+      (str:'FUNCTION'      ;special:false;keyword:m_all;op:NOTOKEN),
+      (str:'OPERATOR'      ;special:false;keyword:m_fpc;op:NOTOKEN),
+      (str:'OVERRIDE'      ;special:false;keyword:m_none;op:NOTOKEN),
+      (str:'POPSTACK'      ;special:false;keyword:m_none;op:NOTOKEN),
+      (str:'PROPERTY'      ;special:false;keyword:m_class;op:NOTOKEN),
+      (str:'REGISTER'      ;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:'ASSEMBLER'     ;special:false;keyword:m_none;op:NOTOKEN),
+      (str:'INHERITED'     ;special:false;keyword:m_all;op:NOTOKEN),
+      (str:'INTERFACE'     ;special:false;keyword:m_all;op:NOTOKEN),
+      (str:'INTERRUPT'     ;special:false;keyword:m_none;op:NOTOKEN),
+      (str:'NODEFAULT'     ;special:false;keyword:m_none;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:'THREADVAR'     ;special:false;keyword:m_class;op:NOTOKEN),
+      (str:'DESTRUCTOR'    ;special:false;keyword:m_all;op:NOTOKEN),
+      (str:'INTERNPROC'    ;special:false;keyword:m_none;op:NOTOKEN),
+      (str:'OPENSTRING'    ;special:false;keyword:m_none;op:NOTOKEN),
+      (str:'CONSTRUCTOR'   ;special:false;keyword:m_all;op:NOTOKEN),
+      (str:'INTERNCONST'   ;special:false;keyword:m_none;op:NOTOKEN),
+      (str:'SHORTSTRING'   ;special:false;keyword:m_none;op:NOTOKEN),
+      (str:'FINALIZATION'  ;special:false;keyword:m_initfinal;op:NOTOKEN),
+      (str:'SAVEREGISTERS' ;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_class;op:NOTOKEN)
   );
 
 var
@@ -496,7 +511,14 @@ end;
 end.
 {
   $Log$
-  Revision 1.17  1999-09-21 20:53:23  florian
+  Revision 1.18  1999-11-15 17:53:00  pierre
+    + one field added for ttoken record for operator
+      linking the id to the corresponding operator token that
+      can now now all be overloaded
+    * overloaded operators are resetted to nil in InitSymtable
+      (bug when trying to compile a uint that overloads operators twice)
+
+  Revision 1.17  1999/09/21 20:53:23  florian
     * fixed 1/s problem from mailing list
 
   Revision 1.16  1999/09/17 09:17:49  peter