* formatting

compiler/nadd.pas

@@ -46,7 +46,7 @@ interface
           function pass_typecheck_internal:tnode;
        public
           resultrealdef : tdef;
-          addnodeflags: TAddNodeFlags;
+          addnodeflags : TAddNodeFlags;
           constructor create(tt : tnodetype;l,r : tnode);override;
           constructor create_internal(tt:tnodetype;l,r:tnode);
           constructor ppuload(t:tnodetype;ppufile:tcompilerppufile);override;
@@ -192,10 +192,9 @@ implementation
     constructor taddnode.create(tt : tnodetype;l,r : tnode);
       begin
          inherited create(tt,l,r);
-         addnodeflags := [];
+         addnodeflags:=[];
       end;
 
-
     constructor taddnode.create_internal(tt:tnodetype;l,r:tnode);
       begin
         create(tt,l,r);
@@ -754,13 +753,13 @@ implementation
                        begin
                          if not(anf_has_pointerdiv in addnodeflags) then
                            internalerror(2008030101);
-                         t := cpointerconstnode.create(qword(v),resultdef)
+                         t:=cpointerconstnode.create(qword(v),resultdef)
                        end
                      else
-                       t := cpointerconstnode.create(qword(v),resultdef)
+                       t:=cpointerconstnode.create(qword(v),resultdef)
                    else
                      if is_integer(ld) then
-                       t := create_simplified_ord_const(v,resultdef,forinline,cs_check_overflow in localswitches)
+                       t:=create_simplified_ord_const(v,resultdef,forinline,cs_check_overflow in localswitches)
                      else
                        t:=cordconstnode.create(v,resultdef,(ld.typ<>enumdef));
                  end;
@@ -1890,7 +1889,7 @@ implementation
         n: taddnode;
       begin
         n:=taddnode(inherited dogetcopy);
-        n.addnodeflags := addnodeflags;
+        n.addnodeflags:=addnodeflags;
         n.resultrealdef:=resultrealdef;
         result:=n;
       end;

compiler/nbas.pas

@@ -71,8 +71,7 @@ interface
        end;
        tfinalizetempsnodeclass = class of tfinalizetempsnode;
 
-       TAsmNodeFlag =
-       (
+       TAsmNodeFlag = (
          asmnf_get_asm_position,
          { Used registers in assembler block }
          asmnf_has_registerlist
@@ -81,7 +80,7 @@ interface
        TAsmNodeFlags = set of TAsmNodeFlag;
 
        tasmnode = class(tnode)
-          asmnodeflags: TAsmNodeFlags;
+          asmnodeflags : TAsmNodeFlags;
           p_asm : TAsmList;
           currenttai : tai;
           constructor create(p : TAsmList);virtual;
@@ -873,7 +872,7 @@ implementation
       begin
         inherited create(asmn);
         p_asm:=p;
-        asmnodeflags := [];
+        asmnodeflags:=[];
         currenttai:=nil;
       end;
 
@@ -882,7 +881,7 @@ implementation
       begin
         inherited create(asmn);
         p_asm:=nil;
-        asmnodeflags := [asmnf_get_asm_position];
+        asmnodeflags:=[asmnf_get_asm_position];
         currenttai:=nil;
       end;
 
@@ -890,7 +889,7 @@ implementation
     destructor tasmnode.destroy;
       begin
         if assigned(p_asm) then
-         p_asm.free;
+          p_asm.free;
         inherited destroy;
       end;
 
@@ -978,14 +977,15 @@ implementation
       var
         n: tasmnode;
       begin
-        n := tasmnode(inherited dogetcopy);
-        n.asmnodeflags := asmnodeflags;
+        n:=tasmnode(inherited dogetcopy);
+        n.asmnodeflags:=asmnodeflags;
         if assigned(p_asm) then
           begin
             n.p_asm:=TAsmList.create;
             n.p_asm.concatlistcopy(p_asm);
           end
-        else n.p_asm := nil;
+        else
+          n.p_asm:=nil;
         n.currenttai:=currenttai;
         result:=n;
       end;

compiler/ncnv.pas

@@ -1835,11 +1835,11 @@ implementation
           CGMessage(type_e_no_addr_of_constant);
         { a dynamic array is a pointer to an array, so to convert it to }
         { an open array, we have to dereference it (JM)                 }
-        result := ctypeconvnode.create_internal(left,cpointerdef.getreusable(resultdef));
+        result:=ctypeconvnode.create_internal(left,cpointerdef.getreusable(resultdef));
         typecheckpass(result);
         { left is reused }
-        left := nil;
-        result := cderefnode.create(result);
+        left:=nil;
+        result:=cderefnode.create(result);
         include(TDerefNode(result).derefnodeflags,drnf_no_checkpointer);
       end;
 

compiler/ninl.pas

@@ -29,15 +29,14 @@ interface
        node,htypechk,symtype,compinnr;
 
     type
-       TInlineNodeFlag =
-       (
+       TInlineNodeFlag = (
          inf_inlineconst
        );
 
        TInlineNodeFlags = set of TInlineNodeFlag;
 
        tinlinenode = class(tunarynode)
-          inlinenodeflags: TInlineNodeFlags;
+          inlinenodeflags : TInlineNodeFlags;
           inlinenumber : tinlinenumber;
           constructor create(number : tinlinenumber;is_const:boolean;l : tnode);virtual;
           constructor createintern(number : tinlinenumber;is_const:boolean;l : tnode);virtual;
@@ -164,9 +163,9 @@ implementation
       begin
          inherited create(inlinen,l);
          if is_const then
-           inlinenodeflags := [inf_inlineconst]
+           inlinenodeflags:=[inf_inlineconst]
          else
-           inlinenodeflags := [];
+           inlinenodeflags:=[];
          inlinenumber:=number;
       end;
 
@@ -175,7 +174,7 @@ implementation
      l : tnode);
       begin
          create(number,is_const,l);
-         inlinenodeflags := [];
+         inlinenodeflags:=[];
          include(flags,nf_internal);
       end;
 
@@ -201,7 +200,7 @@ implementation
          n : tinlinenode;
       begin
          n:=tinlinenode(inherited dogetcopy);
-         n.inlinenodeflags := inlinenodeflags;
+         n.inlinenodeflags:=inlinenodeflags;
          n.inlinenumber:=inlinenumber;
          result:=n;
       end;
@@ -5466,7 +5465,7 @@ implementation
                      inserttypeconv_internal(n,voidpointertype);
                      arrconstr:=carrayconstructornode.create(n,arrconstr);
                    end;
-                 Include(arrconstr.arrayconstructornodeflags, acnf_allow_array_constructor);
+                 Include(arrconstr.arrayconstructornodeflags,acnf_allow_array_constructor);
 
                  { based on the code from nopt.genmultistringadd() }
                  tempnode:=ctempcreatenode.create(arrn.resultdef,arrn.resultdef.size,tt_persistent,true);

compiler/nld.pas

@@ -95,7 +95,7 @@ interface
          protected
           function direct_shortstring_assignment: boolean; virtual;
          public
-          assignmentnodeflags: TAssignmentNodeFlags;
+          assignmentnodeflags : TAssignmentNodeFlags;
           assigntype : tassigntype;
           constructor create(l,r : tnode);virtual;
           { no checks for validity of assignment }
@@ -124,8 +124,7 @@ interface
        end;
        tarrayconstructorrangenodeclass = class of tarrayconstructorrangenode;
 
-       TArrayConstructorNodeFlag =
-       (
+       TArrayConstructorNodeFlag = (
          acnf_allow_array_constructor,
          acnf_forcevaria,
          acnf_novariaallowed
@@ -134,15 +133,15 @@ interface
        TArrayConstructorNodeFlags = set of TArrayConstructorNodeFlag;
 
        tarrayconstructornode = class(tbinarynode)
-          arrayconstructornodeflags: TArrayConstructorNodeFlags;
+          arrayconstructornodeflags : TArrayConstructorNodeFlags;
          private
           function has_range_node:boolean;
          protected
-          procedure wrapmanagedvarrec(var n: tnode);virtual;abstract;
+          procedure wrapmanagedvarrec(var n : tnode);virtual;abstract;
          public
           constructor create(l,r : tnode);virtual;
-          constructor ppuload(t:tnodetype;ppufile:tcompilerppufile);override;
-          procedure ppuwrite(ppufile:tcompilerppufile);override;
+          constructor ppuload(t : tnodetype;ppufile : tcompilerppufile);override;
+          procedure ppuwrite(ppufile : tcompilerppufile);override;
           function dogetcopy : tnode;override;
           function pass_1 : tnode;override;
           function pass_typecheck:tnode;override;
@@ -638,7 +637,7 @@ implementation
 
       begin
          inherited create(assignn,l,r);
-         assignmentnodeflags := [];
+         assignmentnodeflags:=[];
          assigntype:=at_normal;
          if r.nodetype = typeconvn then
            ttypeconvnode(r).warn_pointer_to_signed:=false;
@@ -675,7 +674,7 @@ implementation
 
       begin
          n:=tassignmentnode(inherited dogetcopy);
-         n.assignmentnodeflags := assignmentnodeflags;
+         n.assignmentnodeflags:=assignmentnodeflags;
          n.assigntype:=assigntype;
          result:=n;
       end;
@@ -1175,7 +1174,7 @@ implementation
     constructor tarrayconstructornode.create(l,r : tnode);
       begin
          inherited create(arrayconstructorn,l,r);
-         arrayconstructornodeflags := [];
+         arrayconstructornodeflags:=[];
       end;
 
 
@@ -1198,7 +1197,7 @@ implementation
          n : tarrayconstructornode;
       begin
          n:=tarrayconstructornode(inherited dogetcopy);
-         n.arrayconstructornodeflags := arrayconstructornodeflags;
+         n.arrayconstructornodeflags:=arrayconstructornodeflags;
          result:=n;
       end;
 

compiler/nmat.pas

@@ -36,7 +36,7 @@ interface
        TModDivNodeFlags = set of TModDivNodeFlag;
 
        tmoddivnode = class(tbinopnode)
-          moddivnodeflags: TModDivNodeFlags;
+          moddivnodeflags : TModDivNodeFlags;
           constructor create(t:tnodetype;l,r : tnode); override;
           constructor ppuload(t:tnodetype;ppufile:tcompilerppufile);override;
           procedure ppuwrite(ppufile:tcompilerppufile);override;
@@ -126,7 +126,7 @@ implementation
     constructor tmoddivnode.create(t:tnodetype;l,r : tnode);
       begin
         inherited create(t, l, r);
-        moddivnodeflags := [];
+        moddivnodeflags:=[];
       end;
 
 
@@ -249,7 +249,7 @@ implementation
         n: tmoddivnode;
       begin
         n:=tmoddivnode(inherited dogetcopy);
-        n.moddivnodeflags := moddivnodeflags;
+        n.moddivnodeflags:=moddivnodeflags;
         result:=n;
       end;
 

compiler/nmem.pas

@@ -103,15 +103,14 @@ interface
        end;
        taddrnodeclass = class of taddrnode;
 
-       TDerefNodeFlag =
-       (
+       TDerefNodeFlag = (
          drnf_no_checkpointer
        );
 
        TDerefNodeFlags = set of TDerefNodeFlag;
 
        tderefnode = class(tunarynode)
-          derefnodeflags: TDerefNodeFlags;
+          derefnodeflags : TDerefNodeFlags;
           constructor create(l : tnode);virtual;
           constructor ppuload(t:tnodetype;ppufile:tcompilerppufile);override;
           procedure ppuwrite(ppufile:tcompilerppufile);override;
@@ -155,13 +154,13 @@ interface
 
        tvecnode = class(tbinarynode)
        protected
-          function first_arraydef: tnode; virtual;
+          function first_arraydef : tnode; virtual;
           function gen_array_rangecheck: tnode; virtual;
        public
           vecnodeflags: TVecNodeFlags;
-          constructor create(l,r : tnode);virtual;
-          constructor ppuload(t:tnodetype;ppufile:tcompilerppufile);override;
-          procedure ppuwrite(ppufile:tcompilerppufile);override;
+          constructor  create(l,r : tnode);virtual;
+          constructor ppuload(t : tnodetype;ppufile : tcompilerppufile);override;
+          procedure ppuwrite(ppufile : tcompilerppufile);override;
           function pass_1 : tnode;override;
           function pass_typecheck:tnode;override;
           function simplify(forinline : boolean) : tnode; override;
@@ -1087,7 +1086,7 @@ implementation
     constructor tvecnode.create(l,r : tnode);
       begin
          inherited create(vecn,l,r);
-         vecnodeflags := [];
+         vecnodeflags:=[];
       end;
 
 
@@ -1485,7 +1484,7 @@ implementation
         n: tvecnode;
       begin
         n:=tvecnode(inherited dogetcopy);
-        n.vecnodeflags := vecnodeflags;
+        n.vecnodeflags:=vecnodeflags;
         result:=n;
       end;
 
@@ -1506,6 +1505,7 @@ implementation
             expectloc:=LOC_SUBSETREF;
       end;
 
+
     function tvecnode.gen_array_rangecheck: tnode;
     var
       htype: tdef;

compiler/optcse.pas

@@ -383,10 +383,10 @@ unit optcse;
                                   if (n.nodetype in [orn,andn]) then
                                     begin
                                       if (tbinarynode(n).left.nodetype in [orn,andn]) then
-                                        taddnode(tbinarynode(n).left).addnodeflags := taddnode(tbinarynode(n).left).addnodeflags +
-                                          (taddnode(n).addnodeflags * [anf_short_bool]);
+                                        taddnode(tbinarynode(n).left).addnodeflags:=taddnode(tbinarynode(n).left).addnodeflags+
+                                          (taddnode(n).addnodeflags*[anf_short_bool]);
 
-                                      exclude(taddnode(n).addnodeflags, anf_short_bool);
+                                      exclude(taddnode(n).addnodeflags,anf_short_bool);
                                     end;
                                 end;
 

compiler/pstatmnt.pas

@@ -1099,8 +1099,8 @@ implementation
 
          { Force an empty register list for pure assembler routines,
            so that pass2 won't allocate volatile registers for them. }
-         if Assigned(asmstat) and (po_assembler in current_procinfo.procdef.procoptions) then
-           Include(asmstat.asmnodeflags, asmnf_has_registerlist);
+         if (po_assembler in current_procinfo.procdef.procoptions) then
+           Include(asmstat.asmnodeflags,asmnf_has_registerlist);
 
          { END is read, got a list of changed registers? }
          if try_to_consume(_LECKKLAMMER) then
@@ -1140,8 +1140,7 @@ implementation
                   if not try_to_consume(_COMMA) then
                     break;
                 until false;
-                if Assigned(asmstat) then
-                  Include(asmstat.asmnodeflags, asmnf_has_registerlist);
+                Include(asmstat.asmnodeflags,asmnf_has_registerlist);
               end;
              consume(_RECKKLAMMER);
            end;