* moved the initialisation of the nodetree and tai class reference constants

    from the unit initialisation sections to the variable declaration sections
    to prevent the base units from overriding derived classes (based on patch
    by Hans-Peter Dietrich, mantis #17516)

git-svn-id: trunk@16118 -

compiler/aasmtai.pas

@@ -642,9 +642,9 @@ interface
       { array with all class types for tais }
       aiclass : taiclassarray;
 
-      { target specific tais }
-      cai_align : tai_align_class;
-      cai_cpu   : tai_cpu_class;
+      { target specific tais, possibly overwritten in target specific aasmcpu }
+      cai_align : tai_align_class = tai_align_abstract;
+      cai_cpu   : tai_cpu_class = tai_cpu_abstract;
 
       { hook to notify uses of registers }
       add_reg_instruction_hook : tadd_reg_instruction_proc;
@@ -2405,11 +2405,4 @@ implementation
         ppufile.putbyte(byte(use_op));
       end;
 
-
-begin
-  cai_cpu:=tai_cpu_abstract;
-  { aasmcpu is earlier in the unit order and can
-    already set the cai_align }
-  if not assigned(cai_align) then
-    cai_align:=tai_align_abstract;
 end.

compiler/nadd.pas

@@ -85,7 +85,7 @@ interface
        { the virtual constructor allows to assign         }
        { another class type to caddnode => processor      }
        { specific node types can be created               }
-       caddnode : taddnodeclass;
+       caddnode : taddnodeclass = taddnode;
 
 implementation
 
@@ -2806,6 +2806,4 @@ implementation
     end;
 {$endif}
 
-begin
-   caddnode:=taddnode;
 end.

compiler/nbas.pas

@@ -194,14 +194,14 @@ type
        ttempdeletenodeclass = class of ttempdeletenode;
 
     var
-       cnothingnode : tnothingnodeclass;
-       cerrornode : terrornodeclass;
-       casmnode : tasmnodeclass;
-       cstatementnode : tstatementnodeclass;
-       cblocknode : tblocknodeclass;
-       ctempcreatenode : ttempcreatenodeclass;
-       ctemprefnode : ttemprefnodeclass;
-       ctempdeletenode : ttempdeletenodeclass;
+       cnothingnode : tnothingnodeclass = tnothingnode;
+       cerrornode : terrornodeclass = terrornode;
+       casmnode : tasmnodeclass = tasmnode;
+       cstatementnode : tstatementnodeclass = tstatementnode;
+       cblocknode : tblocknodeclass = tblocknode;
+       ctempcreatenode : ttempcreatenodeclass = ttempcreatenode;
+       ctemprefnode : ttemprefnodeclass = ttemprefnode;
+       ctempdeletenode : ttempdeletenodeclass = ttempdeletenode;
 
        { Create a blocknode and statement node for multiple statements
          generated internally by the parser }
@@ -1127,13 +1127,4 @@ implementation
           tempinfo^.typedef.GetTypeName,'", tempinfo = $',hexstr(ptrint(tempinfo),sizeof(ptrint)*2));
       end;
 
-begin
-   cnothingnode:=tnothingnode;
-   cerrornode:=terrornode;
-   casmnode:=tasmnode;
-   cstatementnode:=tstatementnode;
-   cblocknode:=tblocknode;
-   ctempcreatenode:=ttempcreatenode;
-   ctemprefnode:=ttemprefnode;
-   ctempdeletenode:=ttempdeletenode;
 end.

compiler/ncal.pas

@@ -224,8 +224,8 @@ interface
     function translate_disp_call(selfnode,parametersnode,putvalue : tnode;methodname : ansistring;dispid : longint;resultdef : tdef) : tnode;
 
     var
-      ccallnode : tcallnodeclass;
-      ccallparanode : tcallparanodeclass;
+      ccallnode : tcallnodeclass = tcallnode;
+      ccallparanode : tcallparanodeclass = tcallparanode;
 
       { Current callnode, this is needed for having a link
        between the callparanodes and the callnode they belong to }
@@ -3803,8 +3803,4 @@ implementation
 {$endif DEBUGINLINE}
       end;
 
-
-begin
-   ccallnode:=tcallnode;
-   ccallparanode:=tcallparanode;
 end.

compiler/ncnv.pas

@@ -219,9 +219,9 @@ interface
        tisnodeclass = class of tisnode;
 
     var
-       ctypeconvnode : ttypeconvnodeclass;
-       casnode : tasnodeclass;
-       cisnode : tisnodeclass;
+       ctypeconvnode : ttypeconvnodeclass = ttypeconvnode;
+       casnode : tasnodeclass = tasnode;
+       cisnode : tisnodeclass=tisnode;
 
     procedure inserttypeconv(var p:tnode;def:tdef);
     procedure inserttypeconv_explicit(var p:tnode;def:tdef);
@@ -3601,9 +3601,4 @@ implementation
          end;
       end;
 
-
-begin
-   ctypeconvnode:=ttypeconvnode;
-   casnode:=tasnode;
-   cisnode:=tisnode;
 end.

compiler/ncon.pas

@@ -178,14 +178,14 @@ interface
        tguidconstnodeclass = class of tguidconstnode;
 
     var
-       cdataconstnode : tdataconstnodeclass;
-       crealconstnode : trealconstnodeclass;
-       cordconstnode : tordconstnodeclass;
-       cpointerconstnode : tpointerconstnodeclass;
-       cstringconstnode : tstringconstnodeclass;
-       csetconstnode : tsetconstnodeclass;
-       cguidconstnode : tguidconstnodeclass;
-       cnilnode : tnilnodeclass;
+       crealconstnode : trealconstnodeclass = trealconstnode;
+       cordconstnode : tordconstnodeclass = tordconstnode;
+       cpointerconstnode : tpointerconstnodeclass = tpointerconstnode;
+       cstringconstnode : tstringconstnodeclass = tstringconstnode;
+       csetconstnode : tsetconstnodeclass = tsetconstnode;
+       cguidconstnode : tguidconstnodeclass = tguidconstnode;
+       cnilnode : tnilnodeclass=tnilnode;
+       cdataconstnode : tdataconstnodeclass = tdataconstnode;
 
     function genintconstnode(v : TConstExprInt) : tordconstnode;
     function genenumnode(v : tenumsym) : tordconstnode;
@@ -1220,13 +1220,4 @@ implementation
           (guid2string(value) = guid2string(tguidconstnode(p).value));
       end;
 
-
-begin
-   crealconstnode:=trealconstnode;
-   cordconstnode:=tordconstnode;
-   cpointerconstnode:=tpointerconstnode;
-   cstringconstnode:=tstringconstnode;
-   csetconstnode:=tsetconstnode;
-   cnilnode:=tnilnode;
-   cguidconstnode:=tguidconstnode;
 end.

compiler/nflw.pas

@@ -205,18 +205,18 @@ interface
        tonnodeclass = class of tonnode;
 
     var
-       cwhilerepeatnode : twhilerepeatnodeclass;
-       cifnode : tifnodeclass;
-       cfornode : tfornodeclass;
-       cexitnode : texitnodeclass;
-       cbreaknode : tbreaknodeclass;
-       ccontinuenode : tcontinuenodeclass;
-       cgotonode : tgotonodeclass;
-       clabelnode : tlabelnodeclass;
-       craisenode : traisenodeclass;
-       ctryexceptnode : ttryexceptnodeclass;
-       ctryfinallynode : ttryfinallynodeclass;
-       connode : tonnodeclass;
+       cwhilerepeatnode : twhilerepeatnodeclass=twhilerepeatnode;
+       cifnode : tifnodeclass = tifnode;
+       cfornode : tfornodeclass = tfornode;
+       cexitnode : texitnodeclass = texitnode;
+       cgotonode : tgotonodeclass = tgotonode;
+       clabelnode : tlabelnodeclass = tlabelnode;
+       craisenode : traisenodeclass = traisenode;
+       ctryexceptnode : ttryexceptnodeclass = ttryexceptnode;
+       ctryfinallynode : ttryfinallynodeclass = ttryfinallynode;
+       connode : tonnodeclass = tonnode;
+       cbreaknode : tbreaknodeclass = tbreaknode;
+       ccontinuenode : tcontinuenodeclass = tcontinuenode;
 
 // for-in loop helpers
 function create_type_for_in_loop(hloopvar, hloopbody, expr: tnode): tnode;
@@ -2105,16 +2105,4 @@ implementation
         docompare := false;
       end;
 
-
-begin
-   cwhilerepeatnode:=twhilerepeatnode;
-   cifnode:=tifnode;
-   cfornode:=tfornode;
-   cexitnode:=texitnode;
-   cgotonode:=tgotonode;
-   clabelnode:=tlabelnode;
-   craisenode:=traisenode;
-   ctryexceptnode:=ttryexceptnode;
-   ctryfinallynode:=ttryfinallynode;
-   connode:=tonnode;
 end.

compiler/ninl.pas

@@ -75,7 +75,7 @@ interface
        tinlinenodeclass = class of tinlinenode;
 
     var
-       cinlinenode : tinlinenodeclass;
+       cinlinenode : tinlinenodeclass = tinlinenode;
 
    function geninlinenode(number : byte;is_const:boolean;l : tnode) : tinlinenode;
 
@@ -3224,6 +3224,4 @@ implementation
          result := loop;
        end;
 
-begin
-   cinlinenode:=tinlinenode;
 end.

compiler/nld.pas

@@ -134,12 +134,12 @@ interface
        trttinodeclass = class of trttinode;
 
     var
-       cloadnode : tloadnodeclass;
-       cassignmentnode : tassignmentnodeclass;
-       carrayconstructorrangenode : tarrayconstructorrangenodeclass;
-       carrayconstructornode : tarrayconstructornodeclass;
-       ctypenode : ttypenodeclass;
-       crttinode : trttinodeclass;
+       cloadnode : tloadnodeclass = tloadnode;
+       cassignmentnode : tassignmentnodeclass = tassignmentnode;
+       carrayconstructorrangenode : tarrayconstructorrangenodeclass = tarrayconstructorrangenode;
+       carrayconstructornode : tarrayconstructornodeclass = tarrayconstructornode;
+       ctypenode : ttypenodeclass = ttypenode;
+       crttinode : trttinodeclass = trttinode;
 
        { Current assignment node }
        aktassignmentnode : tassignmentnode;
@@ -1187,12 +1187,4 @@ implementation
           (rttitype = trttinode(p).rttitype);
       end;
 
-
-begin
-   cloadnode:=tloadnode;
-   cassignmentnode:=tassignmentnode;
-   carrayconstructorrangenode:=tarrayconstructorrangenode;
-   carrayconstructornode:=tarrayconstructornode;
-   ctypenode:=ttypenode;
-   crttinode:=trttinode;
 end.

compiler/nmat.pas

@@ -79,10 +79,10 @@ interface
        tnotnodeclass = class of tnotnode;
 
     var
-       cmoddivnode : tmoddivnodeclass;
-       cshlshrnode : tshlshrnodeclass;
-       cunaryminusnode : tunaryminusnodeclass;
-       cnotnode : tnotnodeclass;
+       cmoddivnode : tmoddivnodeclass = tmoddivnode;
+       cshlshrnode : tshlshrnodeclass = tshlshrnode;
+       cunaryminusnode : tunaryminusnodeclass = tunaryminusnode;
+       cnotnode : tnotnodeclass = tnotnode;
 
 implementation
 
@@ -938,9 +938,4 @@ implementation
       end;
 {$endif}
 
-begin
-   cmoddivnode:=tmoddivnode;
-   cshlshrnode:=tshlshrnode;
-   cunaryminusnode:=tunaryminusnode;
-   cnotnode:=tnotnode;
 end.

compiler/nmem.pas

@@ -117,13 +117,13 @@ interface
        twithnodeclass = class of twithnode;
 
     var
-       cloadvmtaddrnode : tloadvmtaddrnodeclass;
-       cloadparentfpnode : tloadparentfpnodeclass;
-       caddrnode : taddrnodeclass;
-       cderefnode : tderefnodeclass;
-       csubscriptnode : tsubscriptnodeclass;
-       cvecnode : tvecnodeclass;
-       cwithnode : twithnodeclass;
+       cloadvmtaddrnode : tloadvmtaddrnodeclass= tloadvmtaddrnode;
+       caddrnode : taddrnodeclass= taddrnode;
+       cderefnode : tderefnodeclass= tderefnode;
+       csubscriptnode : tsubscriptnodeclass= tsubscriptnode;
+       cvecnode : tvecnodeclass= tvecnode;
+       cwithnode : twithnodeclass= twithnode;
+       cloadparentfpnode : tloadparentfpnodeclass = tloadparentfpnode;
 
     function is_big_untyped_addrnode(p: tnode): boolean;
 
@@ -1016,11 +1016,4 @@ implementation
 	  not (nf_typedaddr in p.flags) and (taddrnode(p).left.resultdef.size > 1);
       end;
 
-begin
-  cloadvmtaddrnode := tloadvmtaddrnode;
-  caddrnode := taddrnode;
-  cderefnode := tderefnode;
-  csubscriptnode := tsubscriptnode;
-  cvecnode := tvecnode;
-  cwithnode := twithnode;
 end.

compiler/nset.pas

@@ -110,10 +110,10 @@ interface
        tcasenodeclass = class of tcasenode;
 
     var
-       csetelementnode : tsetelementnodeclass;
-       cinnode : tinnodeclass;
-       crangenode : trangenodeclass;
-       ccasenode : tcasenodeclass;
+       csetelementnode : tsetelementnodeclass = tsetelementnode;
+       cinnode : tinnodeclass = tinnode;
+       crangenode : trangenodeclass = trangenode;
+       ccasenode : tcasenodeclass = tcasenode;
 
     { counts the labels }
     function case_count_labels(root : pcaselabel) : longint;
@@ -1017,9 +1017,4 @@ implementation
         insertlabel(labels);
       end;
 
-begin
-   csetelementnode:=tsetelementnode;
-   cinnode:=tinnode;
-   crangenode:=trangenode;
-   ccasenode:=tcasenode;
 end.