Fix NAG compiler issues in GMAO_Shared

- Fix m_ioutil.F90: Use TRANSFER() intrinsic for type-safe byte swapping
  in swapI4_ and swapI8_ functions instead of direct type punning

- Fix mpi0/mpi0_copy.F90: Implement TRANSFER-based type conversions using
  BLOCK constructs for all non-INTEGER MPI types (REAL, DOUBLE_PRECISION,
  LOGICAL, CHARACTER) to satisfy NAG's strict type checking

- Fix windfix.F90: Correct array section syntax from scalar notation
  (e.g., dglo(1,1,l)) to proper array slices (e.g., dglo(:,:,l)) for
  calls to GETDIV and VELPOT_SP

- Update GMAO_mpeu/CMakeLists.txt: Comment out duplicate MISMATCH flags
  that are now in common_Fortran_flags to avoid compilation errors

All changes maintain backwards compatibility with gfortran and other
compilers while fixing NAG compiler strict type checking issues.

Author: weiyuan-jiang

GEOS_Shared/windfix.F90

@@ -104,7 +104,7 @@ subroutine windfix ( ua,va,plea,                            &
 ! --------------------------------
       if (size(uglo)>1) then
          do l=1,size(uglo,3)
-            call getdiv (uglo(1,1,l),vglo(1,1,l),dpglo(1,1,l),dglo(1,1,l),img,jmg )
+            call getdiv (uglo(:,:,l),vglo(:,:,l),dpglo(:,:,l),dglo(:,:,l),img,jmg )
          enddo
       end if
 
@@ -134,7 +134,7 @@ subroutine windfix ( ua,va,plea,                            &
 ! --------------------------------
       if (size(dpglo)>1) then
          do l=1,size(uglo,3)
-            call getdiv (uglo(1,1,l),vglo(1,1,l),dpglo(1,1,l),dglo(1,1,l),img,jmg )
+            call getdiv (uglo(:,:,l),vglo(:,:,l),dpglo(:,:,l),dglo(:,:,l),img,jmg )
          enddo
       end if
 
@@ -211,7 +211,7 @@ subroutine windfix ( ua,va,plea,                            &
 ! ------------------------------------------------------------
       if (size(dpglo)>1) then
          do l=1,size(dglo,3)
-             call VELPOT_SP (dglo(1,1,l),chi,img,jmg)
+             call VELPOT_SP (dglo(:,:,l),chi,img,jmg)
              call gradq     (chi,  uchi,vchi,img,jmg)
              uglo(:,:,l) = uglo(:,:,l) + uchi(:,:)/dpglo(:,:,l)
              vglo(:,:,l) = vglo(:,:,l) + vchi(:,:)/dpglo(:,:,l)

GMAO_mpeu/CMakeLists.txt

@@ -57,9 +57,9 @@ file (MAKE_DIRECTORY ${esma_etc}/GMAO_eu)
 set_source_files_properties (m_FileResolv.f90 PROPERTIES COMPILE_FLAGS ${PP})
 
 # NAG notices if the same procedure is called with varying types in the absence
-# of an explicit interface.
-target_compile_options (${this} PRIVATE $<$<COMPILE_LANGUAGE:Fortran>:${MISMATCH}>)
-target_compile_options (GMAO_eu PRIVATE $<$<COMPILE_LANGUAGE:Fortran>:${MISMATCH}>)
+# of an explicit interface. The MISMATCH flag is now in common_Fortran_flags.
+# target_compile_options (${this} PRIVATE $<$<COMPILE_LANGUAGE:Fortran>:${MISMATCH}>)
+# target_compile_options (GMAO_eu PRIVATE $<$<COMPILE_LANGUAGE:Fortran>:${MISMATCH}>)
 
 file (COPY assert.H DESTINATION ${include_${this}})
 file (COPY assert.H DESTINATION ${esma_include}/GMAO_eu)

GMAO_mpeu/m_ioutil.F90

@@ -497,11 +497,12 @@ function swapI4_(ibuf)
 !EOP ___________________________________________________________________
 
   character(len=*),parameter :: myname_=myname//'::swapI4_'
+  character(len=1),dimension(4*size(ibuf)) :: cbuf_in, cbuf_out
 
-  	! TRANSFER() should be used.  The current implementation may be
-	! not fully portable.
-
-  call ioutil_byteswap_(size(ibuf),4,ibuf,swapI4_)
+  	! Use TRANSFER() for proper type conversion (NAG-safe)
+  cbuf_in = transfer(ibuf, cbuf_in)
+  call ioutil_byteswap_(size(ibuf),4,cbuf_in,cbuf_out)
+  swapI4_ = transfer(cbuf_out, swapI4_)
 
 end function swapI4_
 
@@ -527,11 +528,12 @@ function swapI8_(ibuf)
 !EOP ___________________________________________________________________
 
   character(len=*),parameter :: myname_=myname//'::swapI8_'
+  character(len=1),dimension(8*size(ibuf)) :: cbuf_in, cbuf_out
 
-  	! TRANSFER() should be used.  The current implementation may be
-	! not fully portable.
-
-  call ioutil_byteswap_(size(ibuf),8,ibuf,swapI8_)
+  	! Use TRANSFER() for proper type conversion (NAG-safe)
+  cbuf_in = transfer(ibuf, cbuf_in)
+  call ioutil_byteswap_(size(ibuf),8,cbuf_in,cbuf_out)
+  swapI8_ = transfer(cbuf_out, swapI8_)
 
 end function swapI8_
 end module m_ioutil

GMAO_mpeu/mpi0/mpi0_copy.F90

@@ -42,25 +42,73 @@ subroutine mpi0_copy(sbuf,scount,stype,rbuf,rcount,rtype,ier)
   if(	  stype==MPI_INTEGER		) then
     call copy_INTEGER(sbuf,rbuf,scount)
   elseif( stype==MPI_REAL		) then
-    call copy_REAL(sbuf,rbuf,scount)
+    ! Use TRANSFER for type safety (NAG-compatible)
+    block
+      real,dimension(scount) :: sbuf_real, rbuf_real
+      sbuf_real = transfer(sbuf(1:scount), sbuf_real)
+      call copy_REAL(sbuf_real,rbuf_real,scount)
+      rbuf(1:scount) = transfer(rbuf_real, rbuf(1:scount))
+    end block
   elseif( stype==MPI_DOUBLE_PRECISION	) then
-    call copy_DOUBLE_PRECISION(sbuf,rbuf,scount)
+    ! Use TRANSFER for type safety (NAG-compatible)
+    block
+      double precision,dimension(scount) :: sbuf_dbl, rbuf_dbl
+      sbuf_dbl = transfer(sbuf(1:scount), sbuf_dbl)
+      call copy_DOUBLE_PRECISION(sbuf_dbl,rbuf_dbl,scount)
+      rbuf(1:scount) = transfer(rbuf_dbl, rbuf(1:scount))
+    end block
   elseif( stype==MPI_LOGICAL		) then
-    call copy_LOGICAL(sbuf,rbuf,scount)
+    ! Use TRANSFER for type safety (NAG-compatible)
+    block
+      logical,dimension(scount) :: sbuf_log, rbuf_log
+      sbuf_log = transfer(sbuf(1:scount), sbuf_log)
+      call copy_LOGICAL(sbuf_log,rbuf_log,scount)
+      rbuf(1:scount) = transfer(rbuf_log, rbuf(1:scount))
+    end block
   elseif( stype==MPI_CHARACTER		) then
-    call copy_CHARACTER(sbuf,rbuf,scount)
+    ! Use TRANSFER for type safety (NAG-compatible)
+    block
+      character,dimension(scount) :: sbuf_char, rbuf_char
+      sbuf_char = transfer(sbuf(1:scount), sbuf_char)
+      call copy_CHARACTER(sbuf_char,rbuf_char,scount)
+      rbuf(1:scount) = transfer(rbuf_char, rbuf(1:scount))
+    end block
   elseif( stype==MPI_INTEGER4		) then
     call copy_INTEGER4(sbuf,rbuf,scount)
   elseif( stype==MPI_REAL4		) then
-    call copy_REAL4(sbuf,rbuf,scount)
+    ! Use TRANSFER for type safety (NAG-compatible)
+    block
+      real,dimension(scount) :: sbuf_r4, rbuf_r4
+      sbuf_r4 = transfer(sbuf(1:scount), sbuf_r4)
+      call copy_REAL4(sbuf_r4,rbuf_r4,scount)
+      rbuf(1:scount) = transfer(rbuf_r4, rbuf(1:scount))
+    end block
   elseif( stype==MPI_REAL8		) then
-    call copy_REAL8(sbuf,rbuf,scount)
+    ! Use TRANSFER for type safety (NAG-compatible)
+    block
+      double precision,dimension(scount) :: sbuf_r8, rbuf_r8
+      sbuf_r8 = transfer(sbuf(1:scount), sbuf_r8)
+      call copy_REAL8(sbuf_r8,rbuf_r8,scount)
+      rbuf(1:scount) = transfer(rbuf_r8, rbuf(1:scount))
+    end block
   elseif( stype==MPI_2INTEGER		) then
     call copy_INTEGER(sbuf,rbuf,2*scount)
   elseif( stype==MPI_2REAL		) then
-    call copy_REAL(sbuf,rbuf,2*scount)
+    ! Use TRANSFER for type safety (NAG-compatible)
+    block
+      real,dimension(2*scount) :: sbuf_real, rbuf_real
+      sbuf_real = transfer(sbuf(1:2*scount), sbuf_real)
+      call copy_REAL(sbuf_real,rbuf_real,2*scount)
+      rbuf(1:2*scount) = transfer(rbuf_real, rbuf(1:2*scount))
+    end block
   elseif( stype==MPI_2DOUBLE_PRECISION	) then
-    call copy_DOUBLE_PRECISION(sbuf,rbuf,2*scount)
+    ! Use TRANSFER for type safety (NAG-compatible)
+    block
+      double precision,dimension(2*scount) :: sbuf_dbl, rbuf_dbl
+      sbuf_dbl = transfer(sbuf(1:2*scount), sbuf_dbl)
+      call copy_DOUBLE_PRECISION(sbuf_dbl,rbuf_dbl,2*scount)
+      rbuf(1:2*scount) = transfer(rbuf_dbl, rbuf(1:2*scount))
+    end block
   else
     ier=stype
     if(stype==0) ier=MPI_UNDEFINED