re PR libfortran/88807 (misleading indentation warnings building libgfortran)

	PR libfortran/88807
	* m4/minloc0.m4: Reindent to avoid -Wmisleading-indentation warnings.
	* generated/minloc0_4_i1.c: Regenerated.
	* generated/minloc0_4_i2.c: Regenerated.
	* generated/minloc0_4_i4.c: Regenerated.
	* generated/minloc0_4_i8.c: Regenerated.
	* generated/minloc0_4_i16.c: Regenerated.
	* generated/minloc0_4_r4.c: Regenerated.
	* generated/minloc0_4_r8.c: Regenerated.
	* generated/minloc0_4_r10.c: Regenerated.
	* generated/minloc0_4_r16.c: Regenerated.
	* generated/minloc0_8_i1.c: Regenerated.
	* generated/minloc0_8_i2.c: Regenerated.
	* generated/minloc0_8_i4.c: Regenerated.
	* generated/minloc0_8_i8.c: Regenerated.
	* generated/minloc0_8_i16.c: Regenerated.
	* generated/minloc0_8_r4.c: Regenerated.
	* generated/minloc0_8_r8.c: Regenerated.
	* generated/minloc0_8_r10.c: Regenerated.
	* generated/minloc0_8_r16.c: Regenerated.
	* generated/minloc0_16_i1.c: Regenerated.
	* generated/minloc0_16_i2.c: Regenerated.
	* generated/minloc0_16_i4.c: Regenerated.
	* generated/minloc0_16_i8.c: Regenerated.
	* generated/minloc0_16_i16.c: Regenerated.
	* generated/minloc0_16_r4.c: Regenerated.
	* generated/minloc0_16_r8.c: Regenerated.
	* generated/minloc0_16_r10.c: Regenerated.
	* generated/minloc0_16_r16.c: Regenerated.

From-SVN: r267875

diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog
index 10fe088..d5fdb48 100644 (file)
--- a/libgfortran/ChangeLog
+++ b/libgfortran/ChangeLog
@@ -1,3 +1,35 @@
+2019-01-12  Jakub Jelinek  <jakub@redhat.com>
+
+       PR libfortran/88807
+       * m4/minloc0.m4: Reindent to avoid -Wmisleading-indentation warnings.
+       * generated/minloc0_4_i1.c: Regenerated.
+       * generated/minloc0_4_i2.c: Regenerated.
+       * generated/minloc0_4_i4.c: Regenerated.
+       * generated/minloc0_4_i8.c: Regenerated.
+       * generated/minloc0_4_i16.c: Regenerated.
+       * generated/minloc0_4_r4.c: Regenerated.
+       * generated/minloc0_4_r8.c: Regenerated.
+       * generated/minloc0_4_r10.c: Regenerated.
+       * generated/minloc0_4_r16.c: Regenerated.
+       * generated/minloc0_8_i1.c: Regenerated.
+       * generated/minloc0_8_i2.c: Regenerated.
+       * generated/minloc0_8_i4.c: Regenerated.
+       * generated/minloc0_8_i8.c: Regenerated.
+       * generated/minloc0_8_i16.c: Regenerated.
+       * generated/minloc0_8_r4.c: Regenerated.
+       * generated/minloc0_8_r8.c: Regenerated.
+       * generated/minloc0_8_r10.c: Regenerated.
+       * generated/minloc0_8_r16.c: Regenerated.
+       * generated/minloc0_16_i1.c: Regenerated.
+       * generated/minloc0_16_i2.c: Regenerated.
+       * generated/minloc0_16_i4.c: Regenerated.
+       * generated/minloc0_16_i8.c: Regenerated.
+       * generated/minloc0_16_i16.c: Regenerated.
+       * generated/minloc0_16_r4.c: Regenerated.
+       * generated/minloc0_16_r8.c: Regenerated.
+       * generated/minloc0_16_r10.c: Regenerated.
+       * generated/minloc0_16_r16.c: Regenerated.
+
 2019-01-09  Sandra Loosemore  <sandra@codesourcery.com>
 
        PR other/16615
@@ -6,8 +38,8 @@
        * io/unit.c: Likewise.
 
 2019-01-07  Thomas Koenig  <tkoenig@gcc.gnu.org>
-       Harald Anlauf <anlauf@gmx.de>
-       Tobias Burnus <burnus@gcc.gnu.org>
+           Harald Anlauf <anlauf@gmx.de>
+           Tobias Burnus <burnus@gcc.gnu.org>
 
        PR fortran/45424
        * Makefile.am: Add intrinsics/is_contiguous.c.

diff --git a/libgfortran/generated/minloc0_16_i1.c b/libgfortran/generated/minloc0_16_i1.c
index 9dd0cb7..b49cafa 100644 (file)
--- a/libgfortran/generated/minloc0_16_i1.c
+++ b/libgfortran/generated/minloc0_16_i1.c
@@ -123,27 +123,27 @@ minloc0_16_i1 (gfc_array_i16 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_16_i16.c b/libgfortran/generated/minloc0_16_i16.c
index 4a782b9..df9ed42 100644 (file)
--- a/libgfortran/generated/minloc0_16_i16.c
+++ b/libgfortran/generated/minloc0_16_i16.c
@@ -123,27 +123,27 @@ minloc0_16_i16 (gfc_array_i16 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_16_i2.c b/libgfortran/generated/minloc0_16_i2.c
index bba2bfd..86f5137 100644 (file)
--- a/libgfortran/generated/minloc0_16_i2.c
+++ b/libgfortran/generated/minloc0_16_i2.c
@@ -123,27 +123,27 @@ minloc0_16_i2 (gfc_array_i16 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_16_i4.c b/libgfortran/generated/minloc0_16_i4.c
index 4df4bbd..8ef528c 100644 (file)
--- a/libgfortran/generated/minloc0_16_i4.c
+++ b/libgfortran/generated/minloc0_16_i4.c
@@ -123,27 +123,27 @@ minloc0_16_i4 (gfc_array_i16 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_16_i8.c b/libgfortran/generated/minloc0_16_i8.c
index a7ace27..e749a71 100644 (file)
--- a/libgfortran/generated/minloc0_16_i8.c
+++ b/libgfortran/generated/minloc0_16_i8.c
@@ -123,27 +123,27 @@ minloc0_16_i8 (gfc_array_i16 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_16_r10.c b/libgfortran/generated/minloc0_16_r10.c
index c36efcf..517d0c5 100644 (file)
--- a/libgfortran/generated/minloc0_16_r10.c
+++ b/libgfortran/generated/minloc0_16_r10.c
@@ -123,27 +123,27 @@ minloc0_16_r10 (gfc_array_i16 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_16_r16.c b/libgfortran/generated/minloc0_16_r16.c
index 47e818e..c367e3a 100644 (file)
--- a/libgfortran/generated/minloc0_16_r16.c
+++ b/libgfortran/generated/minloc0_16_r16.c
@@ -123,27 +123,27 @@ minloc0_16_r16 (gfc_array_i16 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_16_r4.c b/libgfortran/generated/minloc0_16_r4.c
index 69ae3f4..c64ed50 100644 (file)
--- a/libgfortran/generated/minloc0_16_r4.c
+++ b/libgfortran/generated/minloc0_16_r4.c
@@ -123,27 +123,27 @@ minloc0_16_r4 (gfc_array_i16 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_16_r8.c b/libgfortran/generated/minloc0_16_r8.c
index 1b4d10e..bf644c6 100644 (file)
--- a/libgfortran/generated/minloc0_16_r8.c
+++ b/libgfortran/generated/minloc0_16_r8.c
@@ -123,27 +123,27 @@ minloc0_16_r8 (gfc_array_i16 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_4_i1.c b/libgfortran/generated/minloc0_4_i1.c
index c555169..b89d504 100644 (file)
--- a/libgfortran/generated/minloc0_4_i1.c
+++ b/libgfortran/generated/minloc0_4_i1.c
@@ -123,27 +123,27 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_4_i16.c b/libgfortran/generated/minloc0_4_i16.c
index c9971bd..b449d61 100644 (file)
--- a/libgfortran/generated/minloc0_4_i16.c
+++ b/libgfortran/generated/minloc0_4_i16.c
@@ -123,27 +123,27 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_4_i2.c b/libgfortran/generated/minloc0_4_i2.c
index 8c3af2f..3df8bae 100644 (file)
--- a/libgfortran/generated/minloc0_4_i2.c
+++ b/libgfortran/generated/minloc0_4_i2.c
@@ -123,27 +123,27 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_4_i4.c b/libgfortran/generated/minloc0_4_i4.c
index 16f5912..a8f6a5d 100644 (file)
--- a/libgfortran/generated/minloc0_4_i4.c
+++ b/libgfortran/generated/minloc0_4_i4.c
@@ -123,27 +123,27 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_4_i8.c b/libgfortran/generated/minloc0_4_i8.c
index 9031277..c7472b2 100644 (file)
--- a/libgfortran/generated/minloc0_4_i8.c
+++ b/libgfortran/generated/minloc0_4_i8.c
@@ -123,27 +123,27 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_4_r10.c b/libgfortran/generated/minloc0_4_r10.c
index b878e49..ef161be 100644 (file)
--- a/libgfortran/generated/minloc0_4_r10.c
+++ b/libgfortran/generated/minloc0_4_r10.c
@@ -123,27 +123,27 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_4_r16.c b/libgfortran/generated/minloc0_4_r16.c
index a79b5dd..1f285ad 100644 (file)
--- a/libgfortran/generated/minloc0_4_r16.c
+++ b/libgfortran/generated/minloc0_4_r16.c
@@ -123,27 +123,27 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_4_r4.c b/libgfortran/generated/minloc0_4_r4.c
index 55f83f2..bb7a5de 100644 (file)
--- a/libgfortran/generated/minloc0_4_r4.c
+++ b/libgfortran/generated/minloc0_4_r4.c
@@ -123,27 +123,27 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_4_r8.c b/libgfortran/generated/minloc0_4_r8.c
index 0091bd7..741dd30 100644 (file)
--- a/libgfortran/generated/minloc0_4_r8.c
+++ b/libgfortran/generated/minloc0_4_r8.c
@@ -123,27 +123,27 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_8_i1.c b/libgfortran/generated/minloc0_8_i1.c
index 384e3b3..2f486e5 100644 (file)
--- a/libgfortran/generated/minloc0_8_i1.c
+++ b/libgfortran/generated/minloc0_8_i1.c
@@ -123,27 +123,27 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_8_i16.c b/libgfortran/generated/minloc0_8_i16.c
index 8429548..c717ec7 100644 (file)
--- a/libgfortran/generated/minloc0_8_i16.c
+++ b/libgfortran/generated/minloc0_8_i16.c
@@ -123,27 +123,27 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_8_i2.c b/libgfortran/generated/minloc0_8_i2.c
index 7a808eb..75405c7 100644 (file)
--- a/libgfortran/generated/minloc0_8_i2.c
+++ b/libgfortran/generated/minloc0_8_i2.c
@@ -123,27 +123,27 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_8_i4.c b/libgfortran/generated/minloc0_8_i4.c
index 5997d61..c04074f 100644 (file)
--- a/libgfortran/generated/minloc0_8_i4.c
+++ b/libgfortran/generated/minloc0_8_i4.c
@@ -123,27 +123,27 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_8_i8.c b/libgfortran/generated/minloc0_8_i8.c
index 43d7cd8..1820918 100644 (file)
--- a/libgfortran/generated/minloc0_8_i8.c
+++ b/libgfortran/generated/minloc0_8_i8.c
@@ -123,27 +123,27 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_8_r10.c b/libgfortran/generated/minloc0_8_r10.c
index e52bf47..b3229eb 100644 (file)
--- a/libgfortran/generated/minloc0_8_r10.c
+++ b/libgfortran/generated/minloc0_8_r10.c
@@ -123,27 +123,27 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_8_r16.c b/libgfortran/generated/minloc0_8_r16.c
index b7a3659..cc83364 100644 (file)
--- a/libgfortran/generated/minloc0_8_r16.c
+++ b/libgfortran/generated/minloc0_8_r16.c
@@ -123,27 +123,27 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_8_r4.c b/libgfortran/generated/minloc0_8_r4.c
index 6160551..46e749f 100644 (file)
--- a/libgfortran/generated/minloc0_8_r4.c
+++ b/libgfortran/generated/minloc0_8_r4.c
@@ -123,27 +123,27 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/generated/minloc0_8_r8.c b/libgfortran/generated/minloc0_8_r8.c
index dee3ea0..b741b24 100644 (file)
--- a/libgfortran/generated/minloc0_8_r8.c
+++ b/libgfortran/generated/minloc0_8_r8.c
@@ -123,27 +123,27 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarray,
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
          /* Implementation end.  */
          /* Advance to the next element.  */
          base += sstride[0];

diff --git a/libgfortran/m4/minloc0.m4 b/libgfortran/m4/minloc0.m4
index 4ff3bed..959bad3 100644 (file)
--- a/libgfortran/m4/minloc0.m4
+++ b/libgfortran/m4/minloc0.m4
@@ -63,27 +63,27 @@ FOREACH_FUNCTION(
        }
       else
 #endif
-    if (back)
-      do
-       {
-         if (unlikely (*base <= minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }
-         base += sstride[0];
-       }
-      while (++count[0] != extent[0]);
-    else
-      do
-        {
-         if (unlikely (*base < minval))
-           {
-             minval = *base;
-             for (n = 0; n < rank; n++)
-               dest[n * dstride] = count[n] + 1;
-           }')
+      if (back)
+       do
+         {
+           if (unlikely (*base <= minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }
+           base += sstride[0];
+         }
+       while (++count[0] != extent[0]);
+      else
+       do
+         {
+           if (unlikely (*base < minval))
+             {
+               minval = *base;
+               for (n = 0; n < rank; n++)
+                 dest[n * dstride] = count[n] + 1;
+             }')
 MASKED_FOREACH_FUNCTION(
 `  atype_name minval;
    int fast = 0;