[gcc(refs/users/mikael/heads/refactor_descriptor_v05)] Correction régression scalar_mask_2
Mikael Morin
mikael@gcc.gnu.org
Fri Jun 13 15:00:55 GMT 2025
https://gcc.gnu.org/g:95293747fddfe8adea655977f6e3a92923dd7446
commit 95293747fddfe8adea655977f6e3a92923dd7446
Author: Mikael Morin <mikael@gcc.gnu.org>
Date: Wed Apr 30 20:18:59 2025 +0200
Correction régression scalar_mask_2
Diff:
---
libgfortran/generated/maxloc0_16_i1.c | 14 +++++++-------
libgfortran/generated/maxloc0_16_i16.c | 14 +++++++-------
libgfortran/generated/maxloc0_16_i2.c | 14 +++++++-------
libgfortran/generated/maxloc0_16_i4.c | 14 +++++++-------
libgfortran/generated/maxloc0_16_i8.c | 14 +++++++-------
libgfortran/generated/maxloc0_16_m1.c | 14 +++++++-------
libgfortran/generated/maxloc0_16_m16.c | 14 +++++++-------
libgfortran/generated/maxloc0_16_m2.c | 14 +++++++-------
libgfortran/generated/maxloc0_16_m4.c | 14 +++++++-------
libgfortran/generated/maxloc0_16_m8.c | 14 +++++++-------
libgfortran/generated/maxloc0_16_r10.c | 14 +++++++-------
libgfortran/generated/maxloc0_16_r16.c | 14 +++++++-------
libgfortran/generated/maxloc0_16_r17.c | 14 +++++++-------
libgfortran/generated/maxloc0_16_r4.c | 14 +++++++-------
libgfortran/generated/maxloc0_16_r8.c | 14 +++++++-------
libgfortran/generated/maxloc0_4_i1.c | 14 +++++++-------
libgfortran/generated/maxloc0_4_i16.c | 14 +++++++-------
libgfortran/generated/maxloc0_4_i2.c | 14 +++++++-------
libgfortran/generated/maxloc0_4_i4.c | 14 +++++++-------
libgfortran/generated/maxloc0_4_i8.c | 14 +++++++-------
libgfortran/generated/maxloc0_4_m1.c | 14 +++++++-------
libgfortran/generated/maxloc0_4_m16.c | 14 +++++++-------
libgfortran/generated/maxloc0_4_m2.c | 14 +++++++-------
libgfortran/generated/maxloc0_4_m4.c | 14 +++++++-------
libgfortran/generated/maxloc0_4_m8.c | 14 +++++++-------
libgfortran/generated/maxloc0_4_r10.c | 14 +++++++-------
libgfortran/generated/maxloc0_4_r16.c | 14 +++++++-------
libgfortran/generated/maxloc0_4_r17.c | 14 +++++++-------
libgfortran/generated/maxloc0_4_r4.c | 14 +++++++-------
libgfortran/generated/maxloc0_4_r8.c | 14 +++++++-------
libgfortran/generated/maxloc0_8_i1.c | 14 +++++++-------
libgfortran/generated/maxloc0_8_i16.c | 14 +++++++-------
libgfortran/generated/maxloc0_8_i2.c | 14 +++++++-------
libgfortran/generated/maxloc0_8_i4.c | 14 +++++++-------
libgfortran/generated/maxloc0_8_i8.c | 14 +++++++-------
libgfortran/generated/maxloc0_8_m1.c | 14 +++++++-------
libgfortran/generated/maxloc0_8_m16.c | 14 +++++++-------
libgfortran/generated/maxloc0_8_m2.c | 14 +++++++-------
libgfortran/generated/maxloc0_8_m4.c | 14 +++++++-------
libgfortran/generated/maxloc0_8_m8.c | 14 +++++++-------
libgfortran/generated/maxloc0_8_r10.c | 14 +++++++-------
libgfortran/generated/maxloc0_8_r16.c | 14 +++++++-------
libgfortran/generated/maxloc0_8_r17.c | 14 +++++++-------
libgfortran/generated/maxloc0_8_r4.c | 14 +++++++-------
libgfortran/generated/maxloc0_8_r8.c | 14 +++++++-------
libgfortran/generated/minloc0_16_i1.c | 14 +++++++-------
libgfortran/generated/minloc0_16_i16.c | 14 +++++++-------
libgfortran/generated/minloc0_16_i2.c | 14 +++++++-------
libgfortran/generated/minloc0_16_i4.c | 14 +++++++-------
libgfortran/generated/minloc0_16_i8.c | 14 +++++++-------
libgfortran/generated/minloc0_16_m1.c | 14 +++++++-------
libgfortran/generated/minloc0_16_m16.c | 14 +++++++-------
libgfortran/generated/minloc0_16_m2.c | 14 +++++++-------
libgfortran/generated/minloc0_16_m4.c | 14 +++++++-------
libgfortran/generated/minloc0_16_m8.c | 14 +++++++-------
libgfortran/generated/minloc0_16_r10.c | 14 +++++++-------
libgfortran/generated/minloc0_16_r16.c | 14 +++++++-------
libgfortran/generated/minloc0_16_r17.c | 14 +++++++-------
libgfortran/generated/minloc0_16_r4.c | 14 +++++++-------
libgfortran/generated/minloc0_16_r8.c | 14 +++++++-------
libgfortran/generated/minloc0_4_i1.c | 14 +++++++-------
libgfortran/generated/minloc0_4_i16.c | 14 +++++++-------
libgfortran/generated/minloc0_4_i2.c | 14 +++++++-------
libgfortran/generated/minloc0_4_i4.c | 14 +++++++-------
libgfortran/generated/minloc0_4_i8.c | 14 +++++++-------
libgfortran/generated/minloc0_4_m1.c | 14 +++++++-------
libgfortran/generated/minloc0_4_m16.c | 14 +++++++-------
libgfortran/generated/minloc0_4_m2.c | 14 +++++++-------
libgfortran/generated/minloc0_4_m4.c | 14 +++++++-------
libgfortran/generated/minloc0_4_m8.c | 14 +++++++-------
libgfortran/generated/minloc0_4_r10.c | 14 +++++++-------
libgfortran/generated/minloc0_4_r16.c | 14 +++++++-------
libgfortran/generated/minloc0_4_r17.c | 14 +++++++-------
libgfortran/generated/minloc0_4_r4.c | 14 +++++++-------
libgfortran/generated/minloc0_4_r8.c | 14 +++++++-------
libgfortran/generated/minloc0_8_i1.c | 14 +++++++-------
libgfortran/generated/minloc0_8_i16.c | 14 +++++++-------
libgfortran/generated/minloc0_8_i2.c | 14 +++++++-------
libgfortran/generated/minloc0_8_i4.c | 14 +++++++-------
libgfortran/generated/minloc0_8_i8.c | 14 +++++++-------
libgfortran/generated/minloc0_8_m1.c | 14 +++++++-------
libgfortran/generated/minloc0_8_m16.c | 14 +++++++-------
libgfortran/generated/minloc0_8_m2.c | 14 +++++++-------
libgfortran/generated/minloc0_8_m4.c | 14 +++++++-------
libgfortran/generated/minloc0_8_m8.c | 14 +++++++-------
libgfortran/generated/minloc0_8_r10.c | 14 +++++++-------
libgfortran/generated/minloc0_8_r16.c | 14 +++++++-------
libgfortran/generated/minloc0_8_r17.c | 14 +++++++-------
libgfortran/generated/minloc0_8_r4.c | 14 +++++++-------
libgfortran/generated/minloc0_8_r8.c | 14 +++++++-------
libgfortran/m4/maxloc0.m4 | 14 +++++++-------
libgfortran/m4/maxloc0s.m4 | 8 ++++----
libgfortran/m4/maxloc1s.m4 | 10 +++++-----
libgfortran/m4/minloc0.m4 | 26 +++++++++++++-------------
libgfortran/m4/minloc0s.m4 | 8 ++++----
libgfortran/m4/minloc1.m4 | 2 +-
libgfortran/m4/minloc1s.m4 | 10 +++++-----
97 files changed, 669 insertions(+), 669 deletions(-)
diff --git a/libgfortran/generated/maxloc0_16_i1.c b/libgfortran/generated/maxloc0_16_i1.c
index 53d83cd4c316..537171998ed7 100644
--- a/libgfortran/generated/maxloc0_16_i1.c
+++ b/libgfortran/generated/maxloc0_16_i1.c
@@ -112,7 +112,7 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_INTEGER_1_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_16_i16.c b/libgfortran/generated/maxloc0_16_i16.c
index b9ba808b698b..0072e2927a6d 100644
--- a/libgfortran/generated/maxloc0_16_i16.c
+++ b/libgfortran/generated/maxloc0_16_i16.c
@@ -112,7 +112,7 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_INTEGER_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_16_i2.c b/libgfortran/generated/maxloc0_16_i2.c
index 1fa648a1d7a7..2e984feb7221 100644
--- a/libgfortran/generated/maxloc0_16_i2.c
+++ b/libgfortran/generated/maxloc0_16_i2.c
@@ -112,7 +112,7 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_INTEGER_2_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_16_i4.c b/libgfortran/generated/maxloc0_16_i4.c
index efc5b736e526..b8673598d7cd 100644
--- a/libgfortran/generated/maxloc0_16_i4.c
+++ b/libgfortran/generated/maxloc0_16_i4.c
@@ -112,7 +112,7 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_INTEGER_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_16_i8.c b/libgfortran/generated/maxloc0_16_i8.c
index f4138efb1d1b..a3888b8d79f5 100644
--- a/libgfortran/generated/maxloc0_16_i8.c
+++ b/libgfortran/generated/maxloc0_16_i8.c
@@ -112,7 +112,7 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_INTEGER_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_16_m1.c b/libgfortran/generated/maxloc0_16_m1.c
index cb77ac5b11f8..4e4b39b5c440 100644
--- a/libgfortran/generated/maxloc0_16_m1.c
+++ b/libgfortran/generated/maxloc0_16_m1.c
@@ -112,7 +112,7 @@ maxloc0_16_m1 (gfc_array_i16 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_16_m1 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_16_m1 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_16_m1 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_UINTEGER_1_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_16_m1 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_16_m1 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_16_m16.c b/libgfortran/generated/maxloc0_16_m16.c
index 5c4ae10c737f..1cdbe6d4c780 100644
--- a/libgfortran/generated/maxloc0_16_m16.c
+++ b/libgfortran/generated/maxloc0_16_m16.c
@@ -112,7 +112,7 @@ maxloc0_16_m16 (gfc_array_i16 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_16_m16 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_16_m16 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_16_m16 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_UINTEGER_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_16_m16 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_16_m16 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_16_m2.c b/libgfortran/generated/maxloc0_16_m2.c
index 864a490c399d..a434b0976631 100644
--- a/libgfortran/generated/maxloc0_16_m2.c
+++ b/libgfortran/generated/maxloc0_16_m2.c
@@ -112,7 +112,7 @@ maxloc0_16_m2 (gfc_array_i16 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_16_m2 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_16_m2 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_16_m2 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_UINTEGER_2_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_16_m2 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_16_m2 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_16_m4.c b/libgfortran/generated/maxloc0_16_m4.c
index 07a92b85348c..877bb1ecc7dd 100644
--- a/libgfortran/generated/maxloc0_16_m4.c
+++ b/libgfortran/generated/maxloc0_16_m4.c
@@ -112,7 +112,7 @@ maxloc0_16_m4 (gfc_array_i16 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_16_m4 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_16_m4 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_16_m4 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_UINTEGER_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_16_m4 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_16_m4 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_16_m8.c b/libgfortran/generated/maxloc0_16_m8.c
index b8388d8322ac..332bff727b87 100644
--- a/libgfortran/generated/maxloc0_16_m8.c
+++ b/libgfortran/generated/maxloc0_16_m8.c
@@ -112,7 +112,7 @@ maxloc0_16_m8 (gfc_array_i16 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_16_m8 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_16_m8 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_16_m8 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_UINTEGER_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_16_m8 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_16_m8 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_16_r10.c b/libgfortran/generated/maxloc0_16_r10.c
index ff25fce43791..2ed7d58adb4c 100644
--- a/libgfortran/generated/maxloc0_16_r10.c
+++ b/libgfortran/generated/maxloc0_16_r10.c
@@ -112,7 +112,7 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_REAL_10_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_16_r16.c b/libgfortran/generated/maxloc0_16_r16.c
index 8dcf8a930a1c..c81f8785d24c 100644
--- a/libgfortran/generated/maxloc0_16_r16.c
+++ b/libgfortran/generated/maxloc0_16_r16.c
@@ -112,7 +112,7 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_REAL_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_16_r17.c b/libgfortran/generated/maxloc0_16_r17.c
index d3fa0f136054..e96edb695c80 100644
--- a/libgfortran/generated/maxloc0_16_r17.c
+++ b/libgfortran/generated/maxloc0_16_r17.c
@@ -112,7 +112,7 @@ maxloc0_16_r17 (gfc_array_i16 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_16_r17 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_16_r17 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_16_r17 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_REAL_17_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_16_r17 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_16_r17 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_16_r4.c b/libgfortran/generated/maxloc0_16_r4.c
index 349b6aafb5d7..0fb9709e45ad 100644
--- a/libgfortran/generated/maxloc0_16_r4.c
+++ b/libgfortran/generated/maxloc0_16_r4.c
@@ -112,7 +112,7 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_REAL_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_16_r8.c b/libgfortran/generated/maxloc0_16_r8.c
index 012b14429332..e9413b0b1f01 100644
--- a/libgfortran/generated/maxloc0_16_r8.c
+++ b/libgfortran/generated/maxloc0_16_r8.c
@@ -112,7 +112,7 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_REAL_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_4_i1.c b/libgfortran/generated/maxloc0_4_i1.c
index dd2cfaf1bb26..3d232d309955 100644
--- a/libgfortran/generated/maxloc0_4_i1.c
+++ b/libgfortran/generated/maxloc0_4_i1.c
@@ -112,7 +112,7 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_INTEGER_1_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_4_i16.c b/libgfortran/generated/maxloc0_4_i16.c
index c7fd5eb98ca6..e4ed5e8f1e41 100644
--- a/libgfortran/generated/maxloc0_4_i16.c
+++ b/libgfortran/generated/maxloc0_4_i16.c
@@ -112,7 +112,7 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_INTEGER_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_4_i2.c b/libgfortran/generated/maxloc0_4_i2.c
index 3b9b1b713b11..0d742a9a9fb8 100644
--- a/libgfortran/generated/maxloc0_4_i2.c
+++ b/libgfortran/generated/maxloc0_4_i2.c
@@ -112,7 +112,7 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_INTEGER_2_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_4_i4.c b/libgfortran/generated/maxloc0_4_i4.c
index 11c01116b2a5..e7e99d61d337 100644
--- a/libgfortran/generated/maxloc0_4_i4.c
+++ b/libgfortran/generated/maxloc0_4_i4.c
@@ -112,7 +112,7 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_INTEGER_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_4_i8.c b/libgfortran/generated/maxloc0_4_i8.c
index c331811bb117..45e6ab06d819 100644
--- a/libgfortran/generated/maxloc0_4_i8.c
+++ b/libgfortran/generated/maxloc0_4_i8.c
@@ -112,7 +112,7 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_INTEGER_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_4_m1.c b/libgfortran/generated/maxloc0_4_m1.c
index 5ccc3b0e6745..403728d3cbc5 100644
--- a/libgfortran/generated/maxloc0_4_m1.c
+++ b/libgfortran/generated/maxloc0_4_m1.c
@@ -112,7 +112,7 @@ maxloc0_4_m1 (gfc_array_i4 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_4_m1 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_4_m1 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_4_m1 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_UINTEGER_1_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_4_m1 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_4_m1 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_4_m16.c b/libgfortran/generated/maxloc0_4_m16.c
index 60e50a1b0cf0..f1de1b76034e 100644
--- a/libgfortran/generated/maxloc0_4_m16.c
+++ b/libgfortran/generated/maxloc0_4_m16.c
@@ -112,7 +112,7 @@ maxloc0_4_m16 (gfc_array_i4 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_4_m16 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_4_m16 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_4_m16 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_UINTEGER_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_4_m16 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_4_m16 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_4_m2.c b/libgfortran/generated/maxloc0_4_m2.c
index 090d7b636340..d987f672a5d1 100644
--- a/libgfortran/generated/maxloc0_4_m2.c
+++ b/libgfortran/generated/maxloc0_4_m2.c
@@ -112,7 +112,7 @@ maxloc0_4_m2 (gfc_array_i4 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_4_m2 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_4_m2 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_4_m2 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_UINTEGER_2_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_4_m2 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_4_m2 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_4_m4.c b/libgfortran/generated/maxloc0_4_m4.c
index f5d88daa41b2..60793ec943df 100644
--- a/libgfortran/generated/maxloc0_4_m4.c
+++ b/libgfortran/generated/maxloc0_4_m4.c
@@ -112,7 +112,7 @@ maxloc0_4_m4 (gfc_array_i4 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_4_m4 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_4_m4 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_4_m4 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_UINTEGER_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_4_m4 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_4_m4 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_4_m8.c b/libgfortran/generated/maxloc0_4_m8.c
index fdcc36ea803d..9d78b86c3129 100644
--- a/libgfortran/generated/maxloc0_4_m8.c
+++ b/libgfortran/generated/maxloc0_4_m8.c
@@ -112,7 +112,7 @@ maxloc0_4_m8 (gfc_array_i4 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_4_m8 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_4_m8 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_4_m8 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_UINTEGER_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_4_m8 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_4_m8 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_4_r10.c b/libgfortran/generated/maxloc0_4_r10.c
index 7a60816f81a6..bca369aa34c4 100644
--- a/libgfortran/generated/maxloc0_4_r10.c
+++ b/libgfortran/generated/maxloc0_4_r10.c
@@ -112,7 +112,7 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_REAL_10_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_4_r16.c b/libgfortran/generated/maxloc0_4_r16.c
index c3bb236713af..e84fff7e1462 100644
--- a/libgfortran/generated/maxloc0_4_r16.c
+++ b/libgfortran/generated/maxloc0_4_r16.c
@@ -112,7 +112,7 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_REAL_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_4_r17.c b/libgfortran/generated/maxloc0_4_r17.c
index 9a35ef0f1a52..73d410bca1e4 100644
--- a/libgfortran/generated/maxloc0_4_r17.c
+++ b/libgfortran/generated/maxloc0_4_r17.c
@@ -112,7 +112,7 @@ maxloc0_4_r17 (gfc_array_i4 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_4_r17 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_4_r17 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_4_r17 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_REAL_17_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_4_r17 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_4_r17 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_4_r4.c b/libgfortran/generated/maxloc0_4_r4.c
index e542957b74c7..f620238d3152 100644
--- a/libgfortran/generated/maxloc0_4_r4.c
+++ b/libgfortran/generated/maxloc0_4_r4.c
@@ -112,7 +112,7 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_REAL_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_4_r8.c b/libgfortran/generated/maxloc0_4_r8.c
index cd58b4237dff..945900b942c1 100644
--- a/libgfortran/generated/maxloc0_4_r8.c
+++ b/libgfortran/generated/maxloc0_4_r8.c
@@ -112,7 +112,7 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_REAL_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_8_i1.c b/libgfortran/generated/maxloc0_8_i1.c
index 6b373d41accd..f480929ea0c8 100644
--- a/libgfortran/generated/maxloc0_8_i1.c
+++ b/libgfortran/generated/maxloc0_8_i1.c
@@ -112,7 +112,7 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_INTEGER_1_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_8_i16.c b/libgfortran/generated/maxloc0_8_i16.c
index 451a8f717e03..b315a0d2f51b 100644
--- a/libgfortran/generated/maxloc0_8_i16.c
+++ b/libgfortran/generated/maxloc0_8_i16.c
@@ -112,7 +112,7 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_INTEGER_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_8_i2.c b/libgfortran/generated/maxloc0_8_i2.c
index c413b302f76b..729648c2eb0c 100644
--- a/libgfortran/generated/maxloc0_8_i2.c
+++ b/libgfortran/generated/maxloc0_8_i2.c
@@ -112,7 +112,7 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_INTEGER_2_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_8_i4.c b/libgfortran/generated/maxloc0_8_i4.c
index a6e500f57659..056167f08e91 100644
--- a/libgfortran/generated/maxloc0_8_i4.c
+++ b/libgfortran/generated/maxloc0_8_i4.c
@@ -112,7 +112,7 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_INTEGER_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_8_i8.c b/libgfortran/generated/maxloc0_8_i8.c
index 59c74778bd99..28c543e4ccfe 100644
--- a/libgfortran/generated/maxloc0_8_i8.c
+++ b/libgfortran/generated/maxloc0_8_i8.c
@@ -112,7 +112,7 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_INTEGER_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_8_m1.c b/libgfortran/generated/maxloc0_8_m1.c
index da5d44136dc4..85f0546113b4 100644
--- a/libgfortran/generated/maxloc0_8_m1.c
+++ b/libgfortran/generated/maxloc0_8_m1.c
@@ -112,7 +112,7 @@ maxloc0_8_m1 (gfc_array_i8 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_8_m1 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_8_m1 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_8_m1 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_UINTEGER_1_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_8_m1 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_8_m1 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_8_m16.c b/libgfortran/generated/maxloc0_8_m16.c
index db5dcbb1d595..f0619436906d 100644
--- a/libgfortran/generated/maxloc0_8_m16.c
+++ b/libgfortran/generated/maxloc0_8_m16.c
@@ -112,7 +112,7 @@ maxloc0_8_m16 (gfc_array_i8 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_8_m16 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_8_m16 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_8_m16 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_UINTEGER_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_8_m16 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_8_m16 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_8_m2.c b/libgfortran/generated/maxloc0_8_m2.c
index efdba4d76027..344a1923c262 100644
--- a/libgfortran/generated/maxloc0_8_m2.c
+++ b/libgfortran/generated/maxloc0_8_m2.c
@@ -112,7 +112,7 @@ maxloc0_8_m2 (gfc_array_i8 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_8_m2 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_8_m2 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_8_m2 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_UINTEGER_2_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_8_m2 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_8_m2 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_8_m4.c b/libgfortran/generated/maxloc0_8_m4.c
index f66a3d7e05af..bd17c7f4319c 100644
--- a/libgfortran/generated/maxloc0_8_m4.c
+++ b/libgfortran/generated/maxloc0_8_m4.c
@@ -112,7 +112,7 @@ maxloc0_8_m4 (gfc_array_i8 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_8_m4 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_8_m4 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_8_m4 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_UINTEGER_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_8_m4 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_8_m4 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_8_m8.c b/libgfortran/generated/maxloc0_8_m8.c
index 4ae7b42115a0..02088376efda 100644
--- a/libgfortran/generated/maxloc0_8_m8.c
+++ b/libgfortran/generated/maxloc0_8_m8.c
@@ -112,7 +112,7 @@ maxloc0_8_m8 (gfc_array_i8 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_8_m8 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_8_m8 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_8_m8 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_UINTEGER_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_8_m8 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_8_m8 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_8_r10.c b/libgfortran/generated/maxloc0_8_r10.c
index 8d880ccc36fd..e48ee5f3e696 100644
--- a/libgfortran/generated/maxloc0_8_r10.c
+++ b/libgfortran/generated/maxloc0_8_r10.c
@@ -112,7 +112,7 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_REAL_10_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_8_r16.c b/libgfortran/generated/maxloc0_8_r16.c
index c4f90c8eec62..c769778b34cc 100644
--- a/libgfortran/generated/maxloc0_8_r16.c
+++ b/libgfortran/generated/maxloc0_8_r16.c
@@ -112,7 +112,7 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_REAL_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_8_r17.c b/libgfortran/generated/maxloc0_8_r17.c
index 47cdd89a46a3..7ad3a2c0a255 100644
--- a/libgfortran/generated/maxloc0_8_r17.c
+++ b/libgfortran/generated/maxloc0_8_r17.c
@@ -112,7 +112,7 @@ maxloc0_8_r17 (gfc_array_i8 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_8_r17 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_8_r17 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_8_r17 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_REAL_17_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_8_r17 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_8_r17 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_8_r4.c b/libgfortran/generated/maxloc0_8_r4.c
index 06443ae1284a..7d17434fe711 100644
--- a/libgfortran/generated/maxloc0_8_r4.c
+++ b/libgfortran/generated/maxloc0_8_r4.c
@@ -112,7 +112,7 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_REAL_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/maxloc0_8_r8.c b/libgfortran/generated/maxloc0_8_r8.c
index cd3a016841ef..6530881b0b5d 100644
--- a/libgfortran/generated/maxloc0_8_r8.c
+++ b/libgfortran/generated/maxloc0_8_r8.c
@@ -112,7 +112,7 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_REAL_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_16_i1.c b/libgfortran/generated/minloc0_16_i1.c
index 1862a22a2759..2ba955c51ab1 100644
--- a/libgfortran/generated/minloc0_16_i1.c
+++ b/libgfortran/generated/minloc0_16_i1.c
@@ -112,7 +112,7 @@ minloc0_16_i1 (gfc_array_i16 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_16_i1 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_16_i1 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_INTEGER_1_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_16_i16.c b/libgfortran/generated/minloc0_16_i16.c
index 3b929c5d8042..1624cc8ea48b 100644
--- a/libgfortran/generated/minloc0_16_i16.c
+++ b/libgfortran/generated/minloc0_16_i16.c
@@ -112,7 +112,7 @@ minloc0_16_i16 (gfc_array_i16 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_16_i16 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_16_i16 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_INTEGER_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_16_i2.c b/libgfortran/generated/minloc0_16_i2.c
index a823bd1320ca..473bf99e70e5 100644
--- a/libgfortran/generated/minloc0_16_i2.c
+++ b/libgfortran/generated/minloc0_16_i2.c
@@ -112,7 +112,7 @@ minloc0_16_i2 (gfc_array_i16 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_16_i2 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_16_i2 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_INTEGER_2_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_16_i4.c b/libgfortran/generated/minloc0_16_i4.c
index 6e12a6d973d7..2cc56a638219 100644
--- a/libgfortran/generated/minloc0_16_i4.c
+++ b/libgfortran/generated/minloc0_16_i4.c
@@ -112,7 +112,7 @@ minloc0_16_i4 (gfc_array_i16 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_16_i4 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_16_i4 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_INTEGER_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_16_i8.c b/libgfortran/generated/minloc0_16_i8.c
index 3330b19889f1..79aed5aa6173 100644
--- a/libgfortran/generated/minloc0_16_i8.c
+++ b/libgfortran/generated/minloc0_16_i8.c
@@ -112,7 +112,7 @@ minloc0_16_i8 (gfc_array_i16 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_16_i8 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_16_i8 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_INTEGER_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_16_m1.c b/libgfortran/generated/minloc0_16_m1.c
index 249356053f2e..fece30079eb7 100644
--- a/libgfortran/generated/minloc0_16_m1.c
+++ b/libgfortran/generated/minloc0_16_m1.c
@@ -112,7 +112,7 @@ minloc0_16_m1 (gfc_array_i16 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_16_m1 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_16_m1 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_16_m1 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_UINTEGER_1_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_16_m1 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_16_m1 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_16_m16.c b/libgfortran/generated/minloc0_16_m16.c
index 7da9b420f68b..832abb532bdf 100644
--- a/libgfortran/generated/minloc0_16_m16.c
+++ b/libgfortran/generated/minloc0_16_m16.c
@@ -112,7 +112,7 @@ minloc0_16_m16 (gfc_array_i16 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_16_m16 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_16_m16 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_16_m16 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_UINTEGER_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_16_m16 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_16_m16 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_16_m2.c b/libgfortran/generated/minloc0_16_m2.c
index 6757420868f8..ae444e97cebd 100644
--- a/libgfortran/generated/minloc0_16_m2.c
+++ b/libgfortran/generated/minloc0_16_m2.c
@@ -112,7 +112,7 @@ minloc0_16_m2 (gfc_array_i16 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_16_m2 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_16_m2 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_16_m2 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_UINTEGER_2_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_16_m2 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_16_m2 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_16_m4.c b/libgfortran/generated/minloc0_16_m4.c
index 843569c25e72..cba10cbdcfaa 100644
--- a/libgfortran/generated/minloc0_16_m4.c
+++ b/libgfortran/generated/minloc0_16_m4.c
@@ -112,7 +112,7 @@ minloc0_16_m4 (gfc_array_i16 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_16_m4 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_16_m4 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_16_m4 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_UINTEGER_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_16_m4 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_16_m4 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_16_m8.c b/libgfortran/generated/minloc0_16_m8.c
index 35628104eb10..e37936bfe6eb 100644
--- a/libgfortran/generated/minloc0_16_m8.c
+++ b/libgfortran/generated/minloc0_16_m8.c
@@ -112,7 +112,7 @@ minloc0_16_m8 (gfc_array_i16 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_16_m8 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_16_m8 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_16_m8 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_UINTEGER_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_16_m8 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_16_m8 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_16_r10.c b/libgfortran/generated/minloc0_16_r10.c
index 4e9d9f5bc286..37ace9e38f95 100644
--- a/libgfortran/generated/minloc0_16_r10.c
+++ b/libgfortran/generated/minloc0_16_r10.c
@@ -112,7 +112,7 @@ minloc0_16_r10 (gfc_array_i16 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_16_r10 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_16_r10 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_REAL_10_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_16_r16.c b/libgfortran/generated/minloc0_16_r16.c
index e794349cb709..33b24bb515a3 100644
--- a/libgfortran/generated/minloc0_16_r16.c
+++ b/libgfortran/generated/minloc0_16_r16.c
@@ -112,7 +112,7 @@ minloc0_16_r16 (gfc_array_i16 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_16_r16 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_16_r16 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_REAL_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_16_r17.c b/libgfortran/generated/minloc0_16_r17.c
index cc886b50ab3a..f9d6e923f13d 100644
--- a/libgfortran/generated/minloc0_16_r17.c
+++ b/libgfortran/generated/minloc0_16_r17.c
@@ -112,7 +112,7 @@ minloc0_16_r17 (gfc_array_i16 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_16_r17 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_16_r17 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_16_r17 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_REAL_17_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_16_r17 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_16_r17 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_16_r4.c b/libgfortran/generated/minloc0_16_r4.c
index ee52aa4ec44c..43fc571b3117 100644
--- a/libgfortran/generated/minloc0_16_r4.c
+++ b/libgfortran/generated/minloc0_16_r4.c
@@ -112,7 +112,7 @@ minloc0_16_r4 (gfc_array_i16 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_16_r4 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_16_r4 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_REAL_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_16_r8.c b/libgfortran/generated/minloc0_16_r8.c
index 73d46a0e424a..0b1220da2e31 100644
--- a/libgfortran/generated/minloc0_16_r8.c
+++ b/libgfortran/generated/minloc0_16_r8.c
@@ -112,7 +112,7 @@ minloc0_16_r8 (gfc_array_i16 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_16_r8 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_16_r8 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
#if defined(GFC_REAL_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_16, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_4_i1.c b/libgfortran/generated/minloc0_4_i1.c
index b6cfdf7bb4fa..eb81163f3e6a 100644
--- a/libgfortran/generated/minloc0_4_i1.c
+++ b/libgfortran/generated/minloc0_4_i1.c
@@ -112,7 +112,7 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_INTEGER_1_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_4_i16.c b/libgfortran/generated/minloc0_4_i16.c
index f471f95b06c0..80610eea0ec9 100644
--- a/libgfortran/generated/minloc0_4_i16.c
+++ b/libgfortran/generated/minloc0_4_i16.c
@@ -112,7 +112,7 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_INTEGER_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_4_i2.c b/libgfortran/generated/minloc0_4_i2.c
index 4eb799cce0a6..5c849456e680 100644
--- a/libgfortran/generated/minloc0_4_i2.c
+++ b/libgfortran/generated/minloc0_4_i2.c
@@ -112,7 +112,7 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_INTEGER_2_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_4_i4.c b/libgfortran/generated/minloc0_4_i4.c
index 00e7eb876974..9675ca67f303 100644
--- a/libgfortran/generated/minloc0_4_i4.c
+++ b/libgfortran/generated/minloc0_4_i4.c
@@ -112,7 +112,7 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_INTEGER_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_4_i8.c b/libgfortran/generated/minloc0_4_i8.c
index 0647675da191..7f4d0986e24c 100644
--- a/libgfortran/generated/minloc0_4_i8.c
+++ b/libgfortran/generated/minloc0_4_i8.c
@@ -112,7 +112,7 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_INTEGER_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_4_m1.c b/libgfortran/generated/minloc0_4_m1.c
index 1790f5078440..e65686a1fee4 100644
--- a/libgfortran/generated/minloc0_4_m1.c
+++ b/libgfortran/generated/minloc0_4_m1.c
@@ -112,7 +112,7 @@ minloc0_4_m1 (gfc_array_i4 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_4_m1 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_4_m1 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_4_m1 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_UINTEGER_1_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_4_m1 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_4_m1 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_4_m16.c b/libgfortran/generated/minloc0_4_m16.c
index 7b92d04a2e7d..79565fc902a5 100644
--- a/libgfortran/generated/minloc0_4_m16.c
+++ b/libgfortran/generated/minloc0_4_m16.c
@@ -112,7 +112,7 @@ minloc0_4_m16 (gfc_array_i4 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_4_m16 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_4_m16 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_4_m16 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_UINTEGER_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_4_m16 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_4_m16 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_4_m2.c b/libgfortran/generated/minloc0_4_m2.c
index 64e7eebad214..2f61412d8a21 100644
--- a/libgfortran/generated/minloc0_4_m2.c
+++ b/libgfortran/generated/minloc0_4_m2.c
@@ -112,7 +112,7 @@ minloc0_4_m2 (gfc_array_i4 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_4_m2 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_4_m2 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_4_m2 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_UINTEGER_2_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_4_m2 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_4_m2 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_4_m4.c b/libgfortran/generated/minloc0_4_m4.c
index 73055dcd7010..9f532cd3dd2b 100644
--- a/libgfortran/generated/minloc0_4_m4.c
+++ b/libgfortran/generated/minloc0_4_m4.c
@@ -112,7 +112,7 @@ minloc0_4_m4 (gfc_array_i4 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_4_m4 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_4_m4 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_4_m4 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_UINTEGER_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_4_m4 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_4_m4 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_4_m8.c b/libgfortran/generated/minloc0_4_m8.c
index 45998766e059..26465c90441d 100644
--- a/libgfortran/generated/minloc0_4_m8.c
+++ b/libgfortran/generated/minloc0_4_m8.c
@@ -112,7 +112,7 @@ minloc0_4_m8 (gfc_array_i4 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_4_m8 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_4_m8 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_4_m8 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_UINTEGER_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_4_m8 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_4_m8 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_4_r10.c b/libgfortran/generated/minloc0_4_r10.c
index 02db740caedf..c4b1c63ed09a 100644
--- a/libgfortran/generated/minloc0_4_r10.c
+++ b/libgfortran/generated/minloc0_4_r10.c
@@ -112,7 +112,7 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_REAL_10_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_4_r16.c b/libgfortran/generated/minloc0_4_r16.c
index 78c22dafa0e7..f73d4209268a 100644
--- a/libgfortran/generated/minloc0_4_r16.c
+++ b/libgfortran/generated/minloc0_4_r16.c
@@ -112,7 +112,7 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_REAL_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_4_r17.c b/libgfortran/generated/minloc0_4_r17.c
index a8dff32891df..88d93cdb84d3 100644
--- a/libgfortran/generated/minloc0_4_r17.c
+++ b/libgfortran/generated/minloc0_4_r17.c
@@ -112,7 +112,7 @@ minloc0_4_r17 (gfc_array_i4 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_4_r17 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_4_r17 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_4_r17 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_REAL_17_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_4_r17 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_4_r17 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_4_r4.c b/libgfortran/generated/minloc0_4_r4.c
index a72790d57382..37133351cfa5 100644
--- a/libgfortran/generated/minloc0_4_r4.c
+++ b/libgfortran/generated/minloc0_4_r4.c
@@ -112,7 +112,7 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_REAL_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_4_r8.c b/libgfortran/generated/minloc0_4_r8.c
index 0e0097fdb6f0..126ec1b5b7d6 100644
--- a/libgfortran/generated/minloc0_4_r8.c
+++ b/libgfortran/generated/minloc0_4_r8.c
@@ -112,7 +112,7 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
#if defined(GFC_REAL_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_4, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_8_i1.c b/libgfortran/generated/minloc0_8_i1.c
index aebc56938110..0bea5d39fcdd 100644
--- a/libgfortran/generated/minloc0_8_i1.c
+++ b/libgfortran/generated/minloc0_8_i1.c
@@ -112,7 +112,7 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_INTEGER_1_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_8_i16.c b/libgfortran/generated/minloc0_8_i16.c
index 31ef610fa692..1cb45e2cfc9e 100644
--- a/libgfortran/generated/minloc0_8_i16.c
+++ b/libgfortran/generated/minloc0_8_i16.c
@@ -112,7 +112,7 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_INTEGER_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_8_i2.c b/libgfortran/generated/minloc0_8_i2.c
index 8a4bc4557684..6b539710bc6d 100644
--- a/libgfortran/generated/minloc0_8_i2.c
+++ b/libgfortran/generated/minloc0_8_i2.c
@@ -112,7 +112,7 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_INTEGER_2_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_8_i4.c b/libgfortran/generated/minloc0_8_i4.c
index 0ab15b24ac19..d166e7e8ef93 100644
--- a/libgfortran/generated/minloc0_8_i4.c
+++ b/libgfortran/generated/minloc0_8_i4.c
@@ -112,7 +112,7 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_INTEGER_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_8_i8.c b/libgfortran/generated/minloc0_8_i8.c
index 8a6c4461eb29..48862098b461 100644
--- a/libgfortran/generated/minloc0_8_i8.c
+++ b/libgfortran/generated/minloc0_8_i8.c
@@ -112,7 +112,7 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_INTEGER_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_INTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_8_m1.c b/libgfortran/generated/minloc0_8_m1.c
index 202f741d8de2..8630dbd10262 100644
--- a/libgfortran/generated/minloc0_8_m1.c
+++ b/libgfortran/generated/minloc0_8_m1.c
@@ -112,7 +112,7 @@ minloc0_8_m1 (gfc_array_i8 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_8_m1 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_8_m1 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_8_m1 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_UINTEGER_1_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_8_m1 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_1*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_8_m1 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_8_m16.c b/libgfortran/generated/minloc0_8_m16.c
index c984d901c8da..27db4e0cf658 100644
--- a/libgfortran/generated/minloc0_8_m16.c
+++ b/libgfortran/generated/minloc0_8_m16.c
@@ -112,7 +112,7 @@ minloc0_8_m16 (gfc_array_i8 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_8_m16 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_8_m16 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_8_m16 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_UINTEGER_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_8_m16 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_8_m16 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_8_m2.c b/libgfortran/generated/minloc0_8_m2.c
index ebcb74c81613..d477c81cdf10 100644
--- a/libgfortran/generated/minloc0_8_m2.c
+++ b/libgfortran/generated/minloc0_8_m2.c
@@ -112,7 +112,7 @@ minloc0_8_m2 (gfc_array_i8 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_8_m2 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_8_m2 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_8_m2 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_UINTEGER_2_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_8_m2 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_2*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_8_m2 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_8_m4.c b/libgfortran/generated/minloc0_8_m4.c
index 4014ebd36853..6a1ea53fc821 100644
--- a/libgfortran/generated/minloc0_8_m4.c
+++ b/libgfortran/generated/minloc0_8_m4.c
@@ -112,7 +112,7 @@ minloc0_8_m4 (gfc_array_i8 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_8_m4 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_8_m4 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_8_m4 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_UINTEGER_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_8_m4 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_8_m4 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_8_m8.c b/libgfortran/generated/minloc0_8_m8.c
index 4f6d142c8d1e..005ed0977e1d 100644
--- a/libgfortran/generated/minloc0_8_m8.c
+++ b/libgfortran/generated/minloc0_8_m8.c
@@ -112,7 +112,7 @@ minloc0_8_m8 (gfc_array_i8 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_8_m8 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_8_m8 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_8_m8 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_UINTEGER_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_8_m8 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_UINTEGER_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_8_m8 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_8_r10.c b/libgfortran/generated/minloc0_8_r10.c
index 5258d5e2e290..e929968a447a 100644
--- a/libgfortran/generated/minloc0_8_r10.c
+++ b/libgfortran/generated/minloc0_8_r10.c
@@ -112,7 +112,7 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_REAL_10_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_10*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_8_r16.c b/libgfortran/generated/minloc0_8_r16.c
index 76af402ef5c9..20b9204e86d8 100644
--- a/libgfortran/generated/minloc0_8_r16.c
+++ b/libgfortran/generated/minloc0_8_r16.c
@@ -112,7 +112,7 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_REAL_16_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_16*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_8_r17.c b/libgfortran/generated/minloc0_8_r17.c
index 089b5fac148c..8842d7893623 100644
--- a/libgfortran/generated/minloc0_8_r17.c
+++ b/libgfortran/generated/minloc0_8_r17.c
@@ -112,7 +112,7 @@ minloc0_8_r17 (gfc_array_i8 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_8_r17 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_8_r17 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_8_r17 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_REAL_17_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_8_r17 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_17*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_8_r17 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_8_r4.c b/libgfortran/generated/minloc0_8_r4.c
index 721f38b87af2..9fb02c2ee1b9 100644
--- a/libgfortran/generated/minloc0_8_r4.c
+++ b/libgfortran/generated/minloc0_8_r4.c
@@ -112,7 +112,7 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_REAL_4_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_4*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/generated/minloc0_8_r8.c b/libgfortran/generated/minloc0_8_r8.c
index 267fd5221213..d29037c28766 100644
--- a/libgfortran/generated/minloc0_8_r8.c
+++ b/libgfortran/generated/minloc0_8_r8.c
@@ -112,7 +112,7 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarray,
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
@@ -130,7 +130,7 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
}
@@ -142,7 +142,7 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
@@ -286,14 +286,14 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
#if defined(GFC_REAL_8_QUIET_NAN)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -312,7 +312,7 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
base = (GFC_REAL_8*) (((char*)base) + sspacing[0]);
}
@@ -324,7 +324,7 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM (GFC_INTEGER_8, dest, n * dspacing) = count[n] + 1;
}
/* Implementation end. */
/* Advance to the next element. */
diff --git a/libgfortran/m4/maxloc0.m4 b/libgfortran/m4/maxloc0.m4
index 585b801b3cee..a8fc80dd6e9d 100644
--- a/libgfortran/m4/maxloc0.m4
+++ b/libgfortran/m4/maxloc0.m4
@@ -52,7 +52,7 @@ FOREACH_FUNCTION(
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
break;
}
base = ('atype_name`*) (((char*)base) + sspacing[0]);
@@ -70,7 +70,7 @@ FOREACH_FUNCTION(
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
}
base = ('atype_name`*) (((char*)base) + sspacing[0]);
}
@@ -82,7 +82,7 @@ FOREACH_FUNCTION(
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
}')
MASKED_FOREACH_FUNCTION(
` atype_name maxval;
@@ -102,14 +102,14 @@ MASKED_FOREACH_FUNCTION(
#if defined('atype_nan`)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
if (*base >= maxval)
#endif
{
fast = 1;
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -128,7 +128,7 @@ MASKED_FOREACH_FUNCTION(
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
}
base = ('atype_name`*) (((char*)base) + sspacing[0]);
}
@@ -140,7 +140,7 @@ MASKED_FOREACH_FUNCTION(
{
maxval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
}')
SCALAR_FOREACH_FUNCTION(`0')
diff --git a/libgfortran/m4/maxloc0s.m4 b/libgfortran/m4/maxloc0s.m4
index d31743b44c3a..fa3006a3c25f 100644
--- a/libgfortran/m4/maxloc0s.m4
+++ b/libgfortran/m4/maxloc0s.m4
@@ -37,7 +37,7 @@ include(iforeach-s.m4)dnl
#define HAVE_BACK_ARG 1
FOREACH_FUNCTION(
-` const atype_name *maxval;
+` const 'atype_name` *maxval;
maxval = NULL;'
,
` if (maxval == NULL || (back ? compare_fcn (base, maxval, len) >= 0 :
@@ -45,11 +45,11 @@ FOREACH_FUNCTION(
{
maxval = base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (rtype_name, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
}')
MASKED_FOREACH_FUNCTION(
-` const atype_name *maxval;
+` const 'atype_name` *maxval;
maxval = NULL;'
,
@@ -59,7 +59,7 @@ MASKED_FOREACH_FUNCTION(
{
maxval = base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (rtype_name, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
}')
SCALAR_FOREACH_FUNCTION(`0')
diff --git a/libgfortran/m4/maxloc1s.m4 b/libgfortran/m4/maxloc1s.m4
index 762862280120..caa50d50dcec 100644
--- a/libgfortran/m4/maxloc1s.m4
+++ b/libgfortran/m4/maxloc1s.m4
@@ -33,24 +33,24 @@ include(ifunction-s.m4)dnl
#define HAVE_BACK_ARG 1
ARRAY_FUNCTION(0,
-` const atype_name *maxval;
+` const 'atype_name` *maxval;
maxval = NULL;
result = 0;',
` if (maxval == NULL || (back ? compare_fcn (src, maxval, string_len) >= 0 :
compare_fcn (src, maxval, string_len) > 0))
{
maxval = src;
- result = (rtype_name)n + 1;
+ result = ('rtype_name`)n + 1;
}', `')
MASKED_ARRAY_FUNCTION(0,
-` const atype_name *maxval;
+` const 'atype_name` *maxval;
maxval = base;
result = 0;',
` if (*msrc)
{
maxval = src;
- result = (rtype_name)n + 1;
+ result = ('rtype_name`)n + 1;
break;
}
}
@@ -60,7 +60,7 @@ MASKED_ARRAY_FUNCTION(0,
compare_fcn (src, maxval, string_len) > 0))
{
maxval = src;
- result = (rtype_name)n + 1;
+ result = ('rtype_name`)n + 1;
}
')
diff --git a/libgfortran/m4/minloc0.m4 b/libgfortran/m4/minloc0.m4
index 791e7a309bb9..0dba58dd1571 100644
--- a/libgfortran/m4/minloc0.m4
+++ b/libgfortran/m4/minloc0.m4
@@ -32,15 +32,15 @@ include(iforeach.m4)dnl
`#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)'
FOREACH_FUNCTION(
-` atype_name minval;
+` 'atype_name` minval;
#if defined('atype_nan`)
int fast = 0;
#endif
#if defined('atype_inf`)
- minval = atype_inf;
+ minval = 'atype_inf`;
#else
- minval = atype_max;
+ minval = 'atype_max`;
#endif',
`#if defined('atype_nan`)
if (unlikely (!fast))
@@ -52,7 +52,7 @@ FOREACH_FUNCTION(
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
break;
}
base = ('atype_name`*) (((char*)base) + sspacing[0]);
@@ -70,7 +70,7 @@ FOREACH_FUNCTION(
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
}
base = ('atype_name`*) (((char*)base) + sspacing[0]);
}
@@ -82,16 +82,16 @@ FOREACH_FUNCTION(
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
}')
MASKED_FOREACH_FUNCTION(
-` atype_name minval;
+` 'atype_name` minval;
int fast = 0;
#if defined('atype_inf`)
- minval = atype_inf;
+ minval = 'atype_inf`;
#else
- minval = atype_max;
+ minval = 'atype_max`;
#endif',
` if (unlikely (!fast))
{
@@ -102,14 +102,14 @@ MASKED_FOREACH_FUNCTION(
#if defined('atype_nan`)
if (unlikely (dest[0] == 0))
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
if (*base <= minval)
#endif
{
fast = 1;
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
break;
}
}
@@ -128,7 +128,7 @@ MASKED_FOREACH_FUNCTION(
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
}
base = ('atype_name`*) (((char*)base) + sspacing[0]);
}
@@ -140,7 +140,7 @@ MASKED_FOREACH_FUNCTION(
{
minval = *base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (index_type, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
}')
SCALAR_FOREACH_FUNCTION(`0')
#endif
diff --git a/libgfortran/m4/minloc0s.m4 b/libgfortran/m4/minloc0s.m4
index d6f0f8d4a073..ed8ed723cffa 100644
--- a/libgfortran/m4/minloc0s.m4
+++ b/libgfortran/m4/minloc0s.m4
@@ -37,7 +37,7 @@ include(iforeach-s.m4)dnl
#define HAVE_BACK_ARG 1
FOREACH_FUNCTION(
-` const atype_name *minval;
+` const 'atype_name` *minval;
minval = NULL;'
,
` if (minval == NULL || (back ? compare_fcn (base, minval, len) <= 0 :
@@ -45,11 +45,11 @@ FOREACH_FUNCTION(
{
minval = base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (rtype_name, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
}')
MASKED_FOREACH_FUNCTION(
-` const atype_name *minval;
+` const 'atype_name` *minval;
minval = NULL;'
,
@@ -59,7 +59,7 @@ MASKED_FOREACH_FUNCTION(
{
minval = base;
for (n = 0; n < rank; n++)
- GFC_ARRAY_ELEM (rtype_name, dest, n * dspacing) = count[n] + 1;
+ GFC_ARRAY_ELEM ('rtype_name`, dest, n * dspacing) = count[n] + 1;
}')
SCALAR_FOREACH_FUNCTION(`0')
diff --git a/libgfortran/m4/minloc1.m4 b/libgfortran/m4/minloc1.m4
index b1178c2c01e2..65f29a6ce83b 100644
--- a/libgfortran/m4/minloc1.m4
+++ b/libgfortran/m4/minloc1.m4
@@ -34,7 +34,7 @@ include(ifunction.m4)dnl
#define HAVE_BACK_ARG 1
ARRAY_FUNCTION(0,
-` atype_name minval;
+` 'atype_name` minval;
#if defined ('atype_inf`)
minval = 'atype_inf`;
#else
diff --git a/libgfortran/m4/minloc1s.m4 b/libgfortran/m4/minloc1s.m4
index f24318e4c56e..db7fa260719d 100644
--- a/libgfortran/m4/minloc1s.m4
+++ b/libgfortran/m4/minloc1s.m4
@@ -33,24 +33,24 @@ include(ifunction-s.m4)dnl
#define HAVE_BACK_ARG 1
ARRAY_FUNCTION(0,
-` const atype_name *minval;
+` const 'atype_name` *minval;
minval = NULL;
result = 0;',
` if (minval == NULL || (back ? compare_fcn (src, minval, string_len) <= 0 :
compare_fcn (src, minval, string_len) < 0))
{
minval = src;
- result = (rtype_name)n + 1;
+ result = ('rtype_name`)n + 1;
}', `')
MASKED_ARRAY_FUNCTION(0,
-` const atype_name *minval;
+` const 'atype_name` *minval;
minval = base;
result = 0;',
` if (*msrc)
{
minval = src;
- result = (rtype_name)n + 1;
+ result = ('rtype_name`)n + 1;
break;
}
}
@@ -60,7 +60,7 @@ MASKED_ARRAY_FUNCTION(0,
compare_fcn (src, minval, string_len) < 0))
{
minval = src;
- result = (rtype_name)n + 1;
+ result = ('rtype_name`)n + 1;
}
')
More information about the Gcc-cvs
mailing list