* Rtti generation moved to ncgutil

  * Assmtai usage of symsym removed
  * operator overloading cleanup up

compiler/defcmp.pas

@@ -95,8 +95,6 @@ interface
       to use on other types }
     function is_subequal(def1, def2: tdef): boolean;
 
-    function assignment_overloaded(from_def,to_def : tdef) : tprocdef;
-
      {# true, if two parameter lists are equal
       if acp is cp_none, all have to match exactly
       if acp is cp_value_equal_const call by value
@@ -123,15 +121,6 @@ implementation
       defutil,symutil;
 
 
-    function assignment_overloaded(from_def,to_def:tdef):tprocdef;
-      begin
-        if assigned(overloaded_operators[_ASSIGNMENT]) then
-          assignment_overloaded:=overloaded_operators[_ASSIGNMENT].search_procdef_assignment_operator(from_def,to_def)
-        else
-          assignment_overloaded:=nil;
-      end;
-
-
     function compare_defs_ext(def_from,def_to : tdef;
                               fromtreetype : tnodetype;
                               explicit : boolean;
@@ -1029,7 +1018,7 @@ implementation
            ((def_from.deftype in [objectdef,recorddef,arraydef,stringdef,variantdef]) or
             (def_to.deftype in [objectdef,recorddef,arraydef,stringdef,variantdef])) then
           begin
-            operatorpd:=assignment_overloaded(def_from,def_to);
+            operatorpd:=search_assignment_operator(def_from,def_to);
             if assigned(operatorpd) then
              eq:=te_convert_operator;
           end;
@@ -1263,7 +1252,12 @@ implementation
 end.
 {
   $Log$
-  Revision 1.43  2004-01-31 14:50:54  peter
+  Revision 1.44  2004-02-04 22:15:15  daniel
+    * Rtti generation moved to ncgutil
+    * Assmtai usage of symsym removed
+    * operator overloading cleanup up
+
+  Revision 1.43  2004/01/31 14:50:54  peter
     * prefere tobject-tobject over tobject-pointer
 
   Revision 1.42  2004/01/14 21:44:16  peter

compiler/htypechk.pas

@@ -411,31 +411,19 @@ implementation
                 else
                   exit;
              end;
-             { check if the operator contains overloaded procdefs }
-             if overloaded_operators[optoken]=nil then
+             operpd:=search_binary_operator(optoken,ld,rd);
+             if operpd=nil then
                begin
-                  CGMessage(parser_e_operator_not_overloaded);
-                  isbinaryoverloaded:=false;
-                  exit;
-               end;
-
-             { Check if the assignment is available, if not then
-               give a message that the types are not compatible }
-             if optoken in [_EQUAL] then
-              begin
-                operpd:=overloaded_operators[optoken].search_procdef_binary_operator(ld,rd);
-                if not assigned(operpd) then
-                 begin
-                   IncompatibleTypes(ld,rd);
-                   isbinaryoverloaded:=false;
-                   exit;
-                 end;
+                 CGMessage(parser_e_operator_not_overloaded);
+                 isbinaryoverloaded:=false;
+                 exit;
                end;
+             inc(operpd.procsym.refs);
 
              { the nil as symtable signs firstcalln that this is
                an overloaded operator }
-             inc(overloaded_operators[optoken].refs);
-             ht:=ccallnode.create(nil,overloaded_operators[optoken],nil,nil);
+             ht:=ccallnode.create(nil,Tprocsym(operpd.procsym),nil,nil);
+
              { we already know the procdef to use for equal, so it can
                skip the overload choosing in callnode.det_resulttype }
              if assigned(operpd) then
@@ -941,7 +929,12 @@ implementation
 end.
 {
   $Log$
-  Revision 1.76  2004-02-03 22:32:53  peter
+  Revision 1.77  2004-02-04 22:15:15  daniel
+    * Rtti generation moved to ncgutil
+    * Assmtai usage of symsym removed
+    * operator overloading cleanup up
+
+  Revision 1.76  2004/02/03 22:32:53  peter
     * renamed xNNbittype to xNNinttype
     * renamed registers32 to registersint
     * replace some s32bit,u32bit with torddef([su]inttype).def.typ

compiler/ncgutil.pas

@@ -98,6 +98,10 @@ interface
     procedure gen_alloc_inline_parast(list:TAAsmoutput;st:tparasymtable);
     procedure gen_free_parast(list:TAAsmoutput;st:tparasymtable);
 
+    { rtti and init/final }
+    procedure generate_rtti(p:Ttypesym);
+    procedure generate_inittable(p:tsym);
+
 
 implementation
 
@@ -2108,10 +2112,88 @@ implementation
       end;
 
 
+    { persistent rtti generation }
+    procedure generate_rtti(p:Ttypesym);
+      var
+        rsym : trttisym;
+        def  : tstoreddef;
+      begin
+        { rtti can only be generated for classes that are always typesyms }
+        def:=tstoreddef(ttypesym(p).restype.def);
+        { there is an error, skip rtti info }
+        if def.deftype=errordef then
+          exit;
+        { only create rtti once for each definition }
+        if not(df_has_rttitable in def.defoptions) then
+         begin
+           { definition should be in the same symtable as the symbol }
+           if p.owner<>def.owner then
+            internalerror(200108262);
+           { create rttisym }
+           rsym:=trttisym.create(p.name,fullrtti);
+           p.owner.insert(rsym);
+           { register rttisym in definition }
+           include(def.defoptions,df_has_rttitable);
+           def.rttitablesym:=rsym;
+           { write rtti data }
+           def.write_child_rtti_data(fullrtti);
+           if (cs_create_smart in aktmoduleswitches) then
+            rttiList.concat(Tai_cut.Create);
+           rttilist.concat(tai_align.create(const_align(pointer_size)));
+           rttiList.concat(Tai_symbol.Create_global(rsym.get_label,0));
+           def.write_rtti_data(fullrtti);
+           rttiList.concat(Tai_symbol_end.Create(rsym.get_label));
+         end;
+      end;
+
+
+    { persistent init table generation }
+    procedure generate_inittable(p:tsym);
+      var
+        rsym : trttisym;
+        def  : tstoreddef;
+      begin
+        { anonymous types are also allowed for records that can be varsym }
+        case p.typ of
+          typesym :
+            def:=tstoreddef(ttypesym(p).restype.def);
+          varsym :
+            def:=tstoreddef(tvarsym(p).vartype.def);
+          else
+            internalerror(200108263);
+        end;
+        { only create inittable once for each definition }
+        if not(df_has_inittable in def.defoptions) then
+         begin
+           { definition should be in the same symtable as the symbol }
+           if p.owner<>def.owner then
+            internalerror(200108264);
+           { create rttisym }
+           rsym:=trttisym.create(p.name,initrtti);
+           p.owner.insert(rsym);
+           { register rttisym in definition }
+           include(def.defoptions,df_has_inittable);
+           def.inittablesym:=rsym;
+           { write inittable data }
+           def.write_child_rtti_data(initrtti);
+           if (cs_create_smart in aktmoduleswitches) then
+            rttiList.concat(Tai_cut.Create);
+           rttilist.concat(tai_align.create(const_align(pointer_size)));
+           rttiList.concat(Tai_symbol.Create_global(rsym.get_label,0));
+           def.write_rtti_data(initrtti);
+           rttiList.concat(Tai_symbol_end.Create(rsym.get_label));
+         end;
+      end;
+
 end.
 {
   $Log$
-  Revision 1.188  2004-02-04 22:01:13  peter
+  Revision 1.189  2004-02-04 22:15:15  daniel
+    * Rtti generation moved to ncgutil
+    * Assmtai usage of symsym removed
+    * operator overloading cleanup up
+
+  Revision 1.188  2004/02/04 22:01:13  peter
     * first try to get cpupara working for x86_64
 
   Revision 1.187  2004/02/03 22:32:54  peter

compiler/ncnv.pas

@@ -1193,9 +1193,9 @@ implementation
           te_convert_operator :
             begin
               include(current_procinfo.flags,pi_do_call);
-              inc(overloaded_operators[_assignment].refs);
+              inc(aprocdef.procsym.refs);
               hp:=ccallnode.create(ccallparanode.create(left,nil),
-                                   overloaded_operators[_assignment],nil,nil);
+                                   Tprocsym(aprocdef.procsym),nil,nil);
               { tell explicitly which def we must use !! (PM) }
               tcallnode(hp).procdefinition:=aprocdef;
               left:=nil;
@@ -2405,7 +2405,12 @@ begin
 end.
 {
   $Log$
-  Revision 1.136  2004-02-03 22:32:54  peter
+  Revision 1.137  2004-02-04 22:15:15  daniel
+    * Rtti generation moved to ncgutil
+    * Assmtai usage of symsym removed
+    * operator overloading cleanup up
+
+  Revision 1.136  2004/02/03 22:32:54  peter
     * renamed xNNbittype to xNNinttype
     * renamed registers32 to registersint
     * replace some s32bit,u32bit with torddef([su]inttype).def.typ

compiler/nmat.pas

@@ -88,7 +88,7 @@ implementation
       systems,tokens,
       verbose,globals,cutils,
       globtype,
-      symconst,symtype,symtable,symdef,defutil,
+      symconst,symtype,symtable,symdef,symsym,defutil,
       htypechk,pass_1,cpubase,
       cgbase,procinfo,
       ncon,ncnv,ncal,nadd;
@@ -589,14 +589,12 @@ implementation
            end
          else
            begin
-              minusdef:=nil;
-              if assigned(overloaded_operators[_minus]) then
-                minusdef:=overloaded_operators[_minus].search_procdef_unary_operator(left.resulttype.def);
+              minusdef:=search_unary_operator(_minus,left.resulttype.def);
               if assigned(minusdef) then
                 begin
-                  inc(overloaded_operators[_minus].refs);
+                  inc(minusdef.procsym.refs);
                   t:=ccallnode.create(ccallparanode.create(left,nil),
-                                      overloaded_operators[_minus],nil,nil);
+                                      Tprocsym(minusdef.procsym),nil,nil);
                   left:=nil;
                   result:=t;
                   exit;
@@ -770,14 +768,12 @@ implementation
              end
          else
            begin
-              notdef:=nil;
-              if assigned(overloaded_operators[_op_not]) then
-                notdef:=overloaded_operators[_op_not].search_procdef_unary_operator(left.resulttype.def);
-              if notdef<>nil then
+              notdef:=search_unary_operator(_op_not,left.resulttype.def);
+              if assigned(notdef) then
                 begin
-                  inc(overloaded_operators[_op_not].refs);
+                  inc(notdef.procsym.refs);
                   t:=ccallnode.create(ccallparanode.create(left,nil),
-                                      overloaded_operators[_op_not],nil,nil);
+                                      Tprocsym(notdef.procsym),nil,nil);
                   left:=nil;
                   result:=t;
                   exit;
@@ -866,7 +862,12 @@ begin
 end.
 {
   $Log$
-  Revision 1.57  2004-02-04 19:22:27  peter
+  Revision 1.58  2004-02-04 22:15:15  daniel
+    * Rtti generation moved to ncgutil
+    * Assmtai usage of symsym removed
+    * operator overloading cleanup up
+
+  Revision 1.57  2004/02/04 19:22:27  peter
   *** empty log message ***
 
   Revision 1.56  2004/02/03 22:32:54  peter

compiler/parser.pas

@@ -318,7 +318,6 @@ implementation
           olddefaultsymtablestack,
           oldsymtablestack : tsymtable;
           oldaktprocsym    : tprocsym;
-          oldoverloaded_operators : toverloaded_operators;
         { cg }
           oldparse_only  : boolean;
         { asmlists }
@@ -384,7 +383,6 @@ implementation
             oldrefsymtable:=refsymtable;
             oldcurrent_procinfo:=current_procinfo;
             oldaktdefproccall:=aktdefproccall;
-            move(overloaded_operators,oldoverloaded_operators,sizeof(toverloaded_operators));
           { save scanner state }
             oldc:=c;
             oldpattern:=pattern;
@@ -450,7 +448,6 @@ implementation
          aktexceptblock:=0;
          exceptblockcounter:=0;
          aktmaxfpuregisters:=-1;
-         fillchar(overloaded_operators,sizeof(toverloaded_operators),0);
        { reset the unit or create a new program }
          if not assigned(current_module) then
           begin
@@ -605,7 +602,6 @@ implementation
                  defaultsymtablestack:=olddefaultsymtablestack;
                  aktdefproccall:=oldaktdefproccall;
                  current_procinfo:=oldcurrent_procinfo;
-                 move(oldoverloaded_operators,overloaded_operators,sizeof(toverloaded_operators));
                  aktsourcecodepage:=oldsourcecodepage;
                  aktlocalswitches:=oldaktlocalswitches;
                  aktmoduleswitches:=oldaktmoduleswitches;
@@ -695,7 +691,12 @@ implementation
 end.
 {
   $Log$
-  Revision 1.59  2004-01-28 22:16:31  peter
+  Revision 1.60  2004-02-04 22:15:15  daniel
+    * Rtti generation moved to ncgutil
+    * Assmtai usage of symsym removed
+    * operator overloading cleanup up
+
+  Revision 1.59  2004/01/28 22:16:31  peter
     * more record alignment fixes
 
   Revision 1.58  2003/10/29 21:02:51  peter

compiler/pdecsub.pas

@@ -694,18 +694,9 @@ implementation
              operation }
            if (potype=potype_operator) then
              begin
-               { is the current overload sym already in the current unit }
-               if assigned(overloaded_operators[optoken]) and
-                  (overloaded_operators[optoken].owner=symtablestack) then
-                 aprocsym:=overloaded_operators[optoken]
-               else
-                 begin
-                   { create the procsym with saving the original case }
-                   aprocsym:=tprocsym.create('$'+sp);
-                   if assigned(overloaded_operators[optoken]) then
-                     overloaded_operators[optoken].concat_procdefs_to(aprocsym);
-                   overloaded_operators[optoken]:=aprocsym;
-                 end;
+               Aprocsym:=Tprocsym(symtablestack.search(sp));
+               if Aprocsym=nil then
+                 Aprocsym:=tprocsym.create('$'+sp);
              end
             else
              aprocsym:=tprocsym.create(orgsp);
@@ -2149,7 +2140,12 @@ const
 end.
 {
   $Log$
-  Revision 1.158  2004-02-03 22:32:54  peter
+  Revision 1.159  2004-02-04 22:15:15  daniel
+    * Rtti generation moved to ncgutil
+    * Assmtai usage of symsym removed
+    * operator overloading cleanup up
+
+  Revision 1.158  2004/02/03 22:32:54  peter
     * renamed xNNbittype to xNNinttype
     * renamed registers32 to registersint
     * replace some s32bit,u32bit with torddef([su]inttype).def.typ

compiler/pmodules.pas

@@ -994,8 +994,6 @@ implementation
          unitst.next:=symtablestack;
          symtablestack:=unitst;
 
-         tstoredsymtable(symtablestack).chainoperators;
-
 {$ifdef DEBUG}
          test_symtablestack;
 {$endif DEBUG}
@@ -1278,8 +1276,6 @@ implementation
          if token=_USES then
            loadunits;
 
-         tstoredsymtable(symtablestack).chainoperators;
-
          { reset ranges/stabs in exported definitions }
          reset_global_defs;
 
@@ -1442,7 +1438,12 @@ implementation
 end.
 {
   $Log$
-  Revision 1.137  2004-01-28 16:48:24  peter
+  Revision 1.138  2004-02-04 22:15:15  daniel
+    * Rtti generation moved to ncgutil
+    * Assmtai usage of symsym removed
+    * operator overloading cleanup up
+
+  Revision 1.137  2004/01/28 16:48:24  peter
   use local string of 8 chars
 
   Revision 1.136  2004/01/04 21:08:09  jonas

compiler/psystem.pas

@@ -44,7 +44,7 @@ implementation
     uses
       globals,globtype,
       symconst,symtype,symsym,symdef,symtable,
-      aasmtai,aasmcpu,
+      aasmtai,aasmcpu,ncgutil,
 {$ifdef GDB}
       gdb,
 {$endif GDB}
@@ -488,7 +488,12 @@ implementation
 end.
 {
   $Log$
-  Revision 1.61  2004-02-03 22:32:54  peter
+  Revision 1.62  2004-02-04 22:15:15  daniel
+    * Rtti generation moved to ncgutil
+    * Assmtai usage of symsym removed
+    * operator overloading cleanup up
+
+  Revision 1.61  2004/02/03 22:32:54  peter
     * renamed xNNbittype to xNNinttype
     * renamed registers32 to registersint
     * replace some s32bit,u32bit with torddef([su]inttype).def.typ

compiler/symbase.pas

@@ -43,7 +43,7 @@ interface
        indexgrowsize    = 64;
 
 {$ifdef GDB}
-       memsizeinc = 2048; { for long stabstrings }
+       memsizeinc = 4096; { for long stabstrings }
 {$endif GDB}
 
 
@@ -334,7 +334,12 @@ implementation
 end.
 {
   $Log$
-  Revision 1.18  2004-01-15 15:16:18  daniel
+  Revision 1.19  2004-02-04 22:15:15  daniel
+    * Rtti generation moved to ncgutil
+    * Assmtai usage of symsym removed
+    * operator overloading cleanup up
+
+  Revision 1.18  2004/01/15 15:16:18  daniel
     * Some minor stuff
     * Managed to eliminate speed effects of string compression
 

compiler/symsym.pas

@@ -36,7 +36,7 @@ interface
        ppu,
        cclasses,symnot,
        { aasm }
-       aasmbase,aasmtai,
+       aasmbase,
        cpuinfo,cpubase,cgbase
        ;
 
@@ -326,10 +326,6 @@ interface
     var
        generrorsym : tsym;
 
-    { rtti and init/final }
-    procedure generate_rtti(p:tsym);
-    procedure generate_inittable(p:tsym);
-
 implementation
 
     uses
@@ -722,6 +718,8 @@ implementation
         pd^.defderef.reset;
         pd^.next:=nil;
         pd^.own:=(pd^.def.procsym=self);
+{        if not pd^.own then
+          internalerror(2222222);}
         { Add at end of list to keep always
           a correct order, also after loading from ppu }
         if assigned(pdlistlast) then
@@ -2373,87 +2371,15 @@ implementation
       end;
 
 
-    { persistent rtti generation }
-    procedure generate_rtti(p:tsym);
-      var
-        rsym : trttisym;
-        def  : tstoreddef;
-      begin
-        { rtti can only be generated for classes that are always typesyms }
-        if not(p.typ=typesym) then
-         internalerror(200108261);
-        def:=tstoreddef(ttypesym(p).restype.def);
-        { there is an error, skip rtti info }
-        if def.deftype=errordef then
-          exit;
-        { only create rtti once for each definition }
-        if not(df_has_rttitable in def.defoptions) then
-         begin
-           { definition should be in the same symtable as the symbol }
-           if p.owner<>def.owner then
-            internalerror(200108262);
-           { create rttisym }
-           rsym:=trttisym.create(p.name,fullrtti);
-           p.owner.insert(rsym);
-           { register rttisym in definition }
-           include(def.defoptions,df_has_rttitable);
-           def.rttitablesym:=rsym;
-           { write rtti data }
-           def.write_child_rtti_data(fullrtti);
-           if (cs_create_smart in aktmoduleswitches) then
-            rttiList.concat(Tai_cut.Create);
-           rttilist.concat(tai_align.create(const_align(pointer_size)));
-           rttiList.concat(Tai_symbol.Create_global(rsym.get_label,0));
-           def.write_rtti_data(fullrtti);
-           rttiList.concat(Tai_symbol_end.Create(rsym.get_label));
-         end;
-      end;
-
-
-    { persistent init table generation }
-    procedure generate_inittable(p:tsym);
-      var
-        rsym : trttisym;
-        def  : tstoreddef;
-      begin
-        { anonymous types are also allowed for records that can be varsym }
-        case p.typ of
-          typesym :
-            def:=tstoreddef(ttypesym(p).restype.def);
-          varsym :
-            def:=tstoreddef(tvarsym(p).vartype.def);
-          else
-            internalerror(200108263);
-        end;
-        { only create inittable once for each definition }
-        if not(df_has_inittable in def.defoptions) then
-         begin
-           { definition should be in the same symtable as the symbol }
-           if p.owner<>def.owner then
-            internalerror(200108264);
-           { create rttisym }
-           rsym:=trttisym.create(p.name,initrtti);
-           p.owner.insert(rsym);
-           { register rttisym in definition }
-           include(def.defoptions,df_has_inittable);
-           def.inittablesym:=rsym;
-           { write inittable data }
-           def.write_child_rtti_data(initrtti);
-           if (cs_create_smart in aktmoduleswitches) then
-            rttiList.concat(Tai_cut.Create);
-           rttilist.concat(tai_align.create(const_align(pointer_size)));
-           rttiList.concat(Tai_symbol.Create_global(rsym.get_label,0));
-           def.write_rtti_data(initrtti);
-           rttiList.concat(Tai_symbol_end.Create(rsym.get_label));
-         end;
-      end;
-
-
-
 end.
 {
   $Log$
-  Revision 1.151  2004-01-31 22:48:31  daniel
+  Revision 1.152  2004-02-04 22:15:15  daniel
+    * Rtti generation moved to ncgutil
+    * Assmtai usage of symsym removed
+    * operator overloading cleanup up
+
+  Revision 1.151  2004/01/31 22:48:31  daniel
     * Fix stabs generation problem reported by Jonas
 
   Revision 1.150  2004/01/31 21:09:58  daniel

compiler/symtable.pas

@@ -82,7 +82,6 @@ interface
           procedure checklabels;
           function  needs_init_final : boolean;
           procedure unchain_overloaded;
-          procedure chainoperators;
 {$ifdef GDB}
           procedure concatstabto(asmlist : taasmoutput);virtual;
           function  getnewtypecount : word; override;
@@ -209,6 +208,9 @@ interface
     function  searchsystype(const s: stringid; var srsym: ttypesym): boolean;
     function  searchsysvar(const s: stringid; var srsym: tvarsym; var symowner: tsymtable): boolean;
     function  search_class_member(pd : tobjectdef;const s : string):tsym;
+    function  search_assignment_operator(from_def,to_def:Tdef):Tprocdef;
+    function  search_unary_operator(op:Ttoken;def:Tdef):Tprocdef;
+    function  search_binary_operator(op:Ttoken;def1,def2:Tdef):Tprocdef;
 
 {*** Object Helpers ***}
     procedure search_class_overloads(aprocsym : tprocsym);
@@ -239,11 +241,6 @@ interface
     procedure InitSymtable;
     procedure DoneSymtable;
 
-    type
-       toverloaded_operators = array[NOTOKEN..last_overloaded] of tprocsym;
-    var
-       overloaded_operators : toverloaded_operators;
-       { unequal is not equal}
     const
        overloaded_names : array [NOTOKEN..last_overloaded] of string[16] =
          ('error',
@@ -873,59 +870,6 @@ implementation
 {$endif GDB}
 
 
-    procedure tstoredsymtable.chainoperators;
-      var
-        t : ttoken;
-        srsym : tsym;
-        srsymtable,
-        storesymtablestack : tsymtable;
-      begin
-         storesymtablestack:=symtablestack;
-         symtablestack:=self;
-         make_ref:=false;
-         for t:=first_overloaded to last_overloaded do
-           begin
-              overloaded_operators[t]:=nil;
-              { each operator has a unique lowercased internal name PM }
-              while assigned(symtablestack) do
-                begin
-                  searchsym(overloaded_names[t],srsym,srsymtable);
-                  if not assigned(srsym) then
-                   begin
-                     if (t=_STARSTAR) then
-                      begin
-                        symtablestack:=systemunit;
-                        searchsym('POWER',srsym,srsymtable);
-                      end;
-                   end;
-                  if assigned(srsym) then
-                    begin
-                       if (srsym.typ<>procsym) then
-                         internalerror(12344321);
-                       { remove all previous chains }
-                       tprocsym(srsym).unchain_overload;
-                       { use this procsym as start ? }
-                       if not assigned(overloaded_operators[t]) then
-                          overloaded_operators[t]:=tprocsym(srsym)
-                       else
-                          { already got a procsym, only add defs defined in the
-                            unit of the current procsym }
-                          Tprocsym(srsym).concat_procdefs_to(overloaded_operators[t]);
-                       symtablestack:=srsym.owner.next;
-                    end
-                  else
-                    begin
-                      symtablestack:=nil;
-                    end;
-                  { search for same procsym in other units }
-                end;
-              symtablestack:=self;
-           end;
-         make_ref:=true;
-         symtablestack:=storesymtablestack;
-      end;
-
-
 {***********************************************
            Process all entries
 ***********************************************}
@@ -2075,6 +2019,80 @@ implementation
       end;
 
 
+    function search_assignment_operator(from_def,to_def:Tdef):Tprocdef;
+
+    var st:Tsymtable;
+        sym:Tprocsym;
+        sv:cardinal;
+
+    begin
+      st:=symtablestack;
+      sv:=getspeedvalue('assign');
+      while st<>nil do
+        begin
+          sym:=Tprocsym(st.speedsearch('assign',sv));
+          if sym<>nil then
+            begin
+              if sym.typ<>procsym then
+                internalerror(200402031);
+              search_assignment_operator:=sym.search_procdef_assignment_operator(from_def,to_def);
+              if search_assignment_operator<>nil then
+                break;
+            end;
+          st:=st.next;
+        end;
+    end;
+
+    function search_unary_operator(op:Ttoken;def:Tdef):Tprocdef;
+
+    var st:Tsymtable;
+        sym:Tprocsym;
+        sv:cardinal;
+
+    begin
+      st:=symtablestack;
+      sv:=getspeedvalue(overloaded_names[op]);
+      while st<>nil do
+        begin
+          sym:=Tprocsym(st.speedsearch(overloaded_names[op],sv));
+          if sym<>nil then
+            begin
+              if sym.typ<>procsym then
+                internalerror(200402031);
+              search_unary_operator:=sym.search_procdef_unary_operator(def);
+              if search_unary_operator<>nil then
+                break;
+            end;
+          st:=st.next;
+        end;
+    end;
+
+
+    function search_binary_operator(op:Ttoken;def1,def2:Tdef):Tprocdef;
+
+    var st:Tsymtable;
+        sym:Tprocsym;
+        sv:cardinal;
+
+    begin
+      st:=symtablestack;
+      sv:=getspeedvalue(overloaded_names[op]);
+      while st<>nil do
+        begin
+          sym:=Tprocsym(st.speedsearch(overloaded_names[op],sv));
+          if sym<>nil then
+            begin
+              if sym.typ<>procsym then
+                internalerror(200402031);
+              search_binary_operator:=sym.search_procdef_binary_operator(def1,def2);
+              if search_binary_operator<>nil then
+                break;
+            end;
+          st:=st.next;
+        end;
+    end;
+
+
     function searchsystype(const s: stringid; var srsym: ttypesym): boolean;
       var
         symowner: tsymtable;
@@ -2346,8 +2364,6 @@ implementation
         { unit aliases }
         unitaliases:=tdictionary.create;
 {$endif}
-        for token:=first_overloaded to last_overloaded do
-         overloaded_operators[token]:=nil;
      end;
 
 
@@ -2364,7 +2380,12 @@ implementation
 end.
 {
   $Log$
-  Revision 1.133  2004-01-31 22:48:31  daniel
+  Revision 1.134  2004-02-04 22:15:16  daniel
+    * Rtti generation moved to ncgutil
+    * Assmtai usage of symsym removed
+    * operator overloading cleanup up
+
+  Revision 1.133  2004/01/31 22:48:31  daniel
     * Fix stabs generation problem reported by Jonas
 
   Revision 1.132  2004/01/31 18:40:15  daniel