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 10fe088ee718ca652b7bf523f0766934c20ca662..d5fdb484377c17cb4bd25d72657fccf092845d24 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 9dd0cb70cd34b4e06df9137959998694666e3814..b49cafaf17da6c0025185c8a1c357a8c7926f189 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 4a782b913f2166149a9e19b56b2e096ad0c6b654..df9ed4290cc067c7a80b45fd2de70ac267910da0 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 bba2bfd5e685815df33464c0cf8742ef0c83feb1..86f5137e7dd2209d3aac3c1637c98c1134977bab 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 4df4bbd397c704cc8f1d56230fc62c0392d2b123..8ef528c91efd7190df21017f1836cace600ff483 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 a7ace27e59bb25abb488f758c01fd37b17368db7..e749a71cb39c3ba889dab3a0b8c3b5a4bfac33e8 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 c36efcf579036f2954361a4590888267e32d7495..517d0c5e538eb1d9dcb55c7491259a7681acfb1b 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 47e818eb87296953c215fed19a3710fc49a38a3e..c367e3a10b6a0445a394330dab30abb34ede6e78 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 69ae3f499cc2d76734c8ea9a1c3d72a391dc5651..c64ed5062999ed2d043b46f788f6b1eeb8f7dd33 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 1b4d10e3f3bc0e68b09f2b7b3e8575c6b998e557..bf644c64d8e0fde9da0a09255bc6c17428d92590 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 c5551698d6528aa15fc91fb14356b95869ed4b89..b89d50497f66fe16119fef76bfc21b0dc1f7c9d8 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 c9971bd3e5ff251ff1878ab8f85b3e5406de494f..b449d61dc7cea9d6112e3709730fa54592c7b84e 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 8c3af2fa1ccc8ed52302a2b0c2471c89b9d1d8fb..3df8baea2a2f1a744e215d2fa8891897fdb3b7c7 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 16f5912ab6ed7f9bb1f416612a2d47f93f9077b0..a8f6a5d405dc58e4f257fd2cdf75493f530a7793 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 903127700a3e221bdfcf93802c9e0f9ab6660267..c7472b263babd2f18b6103b0ab8e2b6103bf77ae 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 b878e498c4bca3ebc7d6e54000c5c5e2380649df..ef161be46544ea7b5651254628a39cc96d01205e 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 a79b5ddfb4df1bfcd3f98f1712907a213a3be973..1f285adb604f28bc759271099bed6798923c1c44 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 55f83f28aaca9f17db661e1704027f5ccea41a44..bb7a5de3f1571386eb08d033b6ceb7dfbe4b62b0 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 0091bd73bb5ea826d99ff6a8116ca04f10f59e64..741dd3003fb575559bf477576afb230baee5fda0 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 384e3b3e24f7b523e8eba8eae2a6074e82fa5883..2f486e53bd95168c4cc86782340922906504062c 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 8429548ff70aad23279497087f42fc20ffdd1a61..c717ec7a1ca9d85799781f10bcab56e582210f26 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 7a808eb77e111a1efc4e4f434ab84a0484bad932..75405c77cfbb524b85f3c5e852653205d883ac74 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 5997d6115cd30a0947c4b183d2e563259654fa1b..c04074fb7b85318f5020cfa5397036e25c641fdf 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 43d7cd8d38410097b36cfae83c86075b2fe57376..1820918afce6943e8c23f4955aa29ba2d96aaf52 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 e52bf4749ecb09752f3a01c81edb433c7480f3b6..b3229eb0bb299d81ecca779e450dd0aa7d80b9e8 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 b7a3659ba9942a7787664826a4851989414c2d3e..cc8336406c910eb46ce7bfc0ffee0882ac399d2d 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 6160551fa8168a2f1106d3b3314b81d10b7341e1..46e749fb995b2adddc7e8775766319189a0daf69 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 dee3ea0d2cdd652a9d6de3e0bd5fb5a9d2dd72d8..b741b242408953ff35f881ef7760721f184e37d3 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 4ff3bed4862146e1a89bb3e4314d88b06159aba5..959bad3936c4295970d5034472b0fe41f3d9c438 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;