+2018-01-31 Janne Blomqvist <jb@gcc.gnu.org>
+
+ * generated/cshift1_16.c (cshift1): Regenerated.
+ * generated/cshift1_4.c (cshift1): Regenerated.
+ * generated/cshift1_8.c (cshift1): Regenerated.
+ * generated/eoshift1_16.c (eoshift1): Regenerated.
+ * generated/eoshift1_4.c (eoshift1): Regenerated.
+ * generated/eoshift1_8.c (eoshift1): Regenerated.
+ * generated/eoshift3_16.c (eoshift3): Regenerated.
+ * generated/eoshift3_4.c (eoshift3): Regenerated.
+ * generated/eoshift3_8.c (eoshift3): Regenerated.
+ * generated/in_pack_c10.c (internal_pack_c10): Regenerated.
+ * generated/in_pack_c16.c (internal_pack_c16): Regenerated.
+ * generated/in_pack_c4.c (internal_pack_c4): Regenerated.
+ * generated/in_pack_c8.c (internal_pack_c8): Regenerated.
+ * generated/in_pack_i1.c (internal_pack_1): Regenerated.
+ * generated/in_pack_i16.c (internal_pack_16): Regenerated.
+ * generated/in_pack_i2.c (internal_pack_2): Regenerated.
+ * generated/in_pack_i4.c (internal_pack_4): Regenerated.
+ * generated/in_pack_i8.c (internal_pack_8): Regenerated.
+ * generated/in_pack_r10.c (internal_pack_r10): Regenerated.
+ * generated/in_pack_r16.c (internal_pack_r16): Regenerated.
+ * generated/in_pack_r4.c (internal_pack_r4): Regenerated.
+ * generated/in_pack_r8.c (internal_pack_r8): Regenerated.
+ * generated/in_unpack_c10.c (internal_unpack_c10): Regenerated.
+ * generated/in_unpack_c16.c (internal_unpack_c16): Regenerated.
+ * generated/in_unpack_c4.c (internal_unpack_c4): Regenerated.
+ * generated/in_unpack_c8.c (internal_unpack_c8): Regenerated.
+ * generated/in_unpack_i1.c (internal_unpack_1): Regenerated.
+ * generated/in_unpack_i16.c (internal_unpack_16): Regenerated.
+ * generated/in_unpack_i2.c (internal_unpack_2): Regenerated.
+ * generated/in_unpack_i4.c (internal_unpack_4): Regenerated.
+ * generated/in_unpack_i8.c (internal_unpack_8): Regenerated.
+ * generated/in_unpack_r10.c (internal_unpack_r10): Regenerated.
+ * generated/in_unpack_r16.c (internal_unpack_r16): Regenerated.
+ * generated/in_unpack_r4.c (internal_unpack_r4): Regenerated.
+ * generated/in_unpack_r8.c (internal_unpack_r8): Regenerated.
+ * generated/reshape_c10.c (reshape_c10): Regenerated.
+ * generated/reshape_c16.c (reshape_c16): Regenerated.
+ * generated/reshape_c4.c (reshape_c4): Regenerated.
+ * generated/reshape_c8.c (reshape_c8): Regenerated.
+ * generated/reshape_i16.c (reshape_16): Regenerated.
+ * generated/reshape_i4.c (reshape_4): Regenerated.
+ * generated/reshape_i8.c (reshape_8): Regenerated.
+ * generated/reshape_r10.c (reshape_r10): Regenerated.
+ * generated/reshape_r16.c (reshape_r16): Regenerated.
+ * generated/reshape_r4.c (reshape_r4): Regenerated.
+ * generated/reshape_r8.c (reshape_r8): Regenerated.
+ * generated/shape_i1.c (shape_1): Regenerated.
+ * generated/shape_i16.c (shape_16): Regenerated.
+ * generated/shape_i2.c (shape_2): Regenerated.
+ * generated/shape_i4.c (shape_4): Regenerated.
+ * generated/shape_i8.c (shape_8): Regenerated.
+ * generated/spread_c10.c (spread_scalar_c10): Regenerated.
+ * generated/spread_c16.c (spread_scalar_c16): Regenerated.
+ * generated/spread_c4.c (spread_scalar_c4): Regenerated.
+ * generated/spread_c8.c (spread_scalar_c8): Regenerated.
+ * generated/spread_i1.c (spread_scalar_i1): Regenerated.
+ * generated/spread_i16.c (spread_scalar_i16): Regenerated.
+ * generated/spread_i2.c (spread_scalar_i2): Regenerated.
+ * generated/spread_i4.c (spread_scalar_i4): Regenerated.
+ * generated/spread_i8.c (spread_scalar_i8): Regenerated.
+ * generated/spread_r10.c (spread_scalar_r10): Regenerated.
+ * generated/spread_r16.c (spread_scalar_r16): Regenerated.
+ * generated/spread_r4.c (spread_scalar_r4): Regenerated.
+ * generated/spread_r8.c (spread_scalar_r8): Regenerated.
+ * intrinsics/random.c (jump): Use size_t for array index in loop.
+ (getosrandom): Likewise.
+ (arandom_r4): Make n an index_type.
+ (arandom_r8): Likewise.
+ (arandom_r10): Likewise.
+ (arandom_r16): Likewise.
+ (scramble_seed): Use size_t for array index in loop.
+ * m4/cshift1.m4: Make i an index_type.
+ * m4/eoshift1.m4: Likewise.
+ * m4/eoshift3.m4: Likewise.
+ * m4/in_pack.m4: Make n an index_type.
+ * m4/in_unpack.m4: Likewise.
+ * m4/reshape.m4: Make n and dim index_type's.
+ * m4/shape.m4: Make n an index_type.
+ * m4/spread.m4: Likewise, use index_type argument rather than
+ copying to int.
+ * runtime/bounds.c (bounds_ifunction_return): Make n an
+ index_type.
+ * runtime/in_pack_generic.c (internal_pack): Likewise.
+ * runtime/in_unpack_generic.c (internal_unpack): Make n and size
+ index_type's.
+
2018-01-30 Thomas Koenig <tkoenig@gcc.gnu.org>
PR fortran/37577
if (ret->base_addr == NULL)
{
- int i;
-
ret->base_addr = xmallocarray (arraysize, size);
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
- for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
+ for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
index_type ub, str;
if (ret->base_addr == NULL)
{
- int i;
-
ret->base_addr = xmallocarray (arraysize, size);
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
- for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
+ for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
index_type ub, str;
if (ret->base_addr == NULL)
{
- int i;
-
ret->base_addr = xmallocarray (arraysize, size);
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
- for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
+ for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
index_type ub, str;
arraysize = size0 ((array_t *) array);
if (ret->base_addr == NULL)
{
- int i;
-
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
- for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
+ for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
index_type ub, str;
arraysize = size0 ((array_t *) array);
if (ret->base_addr == NULL)
{
- int i;
-
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
- for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
+ for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
index_type ub, str;
arraysize = size0 ((array_t *) array);
if (ret->base_addr == NULL)
{
- int i;
-
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
- for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
+ for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
index_type ub, str;
if (ret->base_addr == NULL)
{
- int i;
-
ret->base_addr = xmallocarray (arraysize, size);
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
- for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
+ for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
index_type ub, str;
if (ret->base_addr == NULL)
{
- int i;
-
ret->base_addr = xmallocarray (arraysize, size);
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
- for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
+ for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
index_type ub, str;
if (ret->base_addr == NULL)
{
- int i;
-
ret->base_addr = xmallocarray (arraysize, size);
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
- for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
+ for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
index_type ub, str;
const GFC_COMPLEX_10 *src;
GFC_COMPLEX_10 * restrict dest;
GFC_COMPLEX_10 *destptr;
- int n;
int packed;
/* TODO: Investigate how we can figure out if this is a temporary
dim = GFC_DESCRIPTOR_RANK (source);
ssize = 1;
packed = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
const GFC_COMPLEX_16 *src;
GFC_COMPLEX_16 * restrict dest;
GFC_COMPLEX_16 *destptr;
- int n;
int packed;
/* TODO: Investigate how we can figure out if this is a temporary
dim = GFC_DESCRIPTOR_RANK (source);
ssize = 1;
packed = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
const GFC_COMPLEX_4 *src;
GFC_COMPLEX_4 * restrict dest;
GFC_COMPLEX_4 *destptr;
- int n;
int packed;
/* TODO: Investigate how we can figure out if this is a temporary
dim = GFC_DESCRIPTOR_RANK (source);
ssize = 1;
packed = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
const GFC_COMPLEX_8 *src;
GFC_COMPLEX_8 * restrict dest;
GFC_COMPLEX_8 *destptr;
- int n;
int packed;
/* TODO: Investigate how we can figure out if this is a temporary
dim = GFC_DESCRIPTOR_RANK (source);
ssize = 1;
packed = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
const GFC_INTEGER_1 *src;
GFC_INTEGER_1 * restrict dest;
GFC_INTEGER_1 *destptr;
- int n;
int packed;
/* TODO: Investigate how we can figure out if this is a temporary
dim = GFC_DESCRIPTOR_RANK (source);
ssize = 1;
packed = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
const GFC_INTEGER_16 *src;
GFC_INTEGER_16 * restrict dest;
GFC_INTEGER_16 *destptr;
- int n;
int packed;
/* TODO: Investigate how we can figure out if this is a temporary
dim = GFC_DESCRIPTOR_RANK (source);
ssize = 1;
packed = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
const GFC_INTEGER_2 *src;
GFC_INTEGER_2 * restrict dest;
GFC_INTEGER_2 *destptr;
- int n;
int packed;
/* TODO: Investigate how we can figure out if this is a temporary
dim = GFC_DESCRIPTOR_RANK (source);
ssize = 1;
packed = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
const GFC_INTEGER_4 *src;
GFC_INTEGER_4 * restrict dest;
GFC_INTEGER_4 *destptr;
- int n;
int packed;
/* TODO: Investigate how we can figure out if this is a temporary
dim = GFC_DESCRIPTOR_RANK (source);
ssize = 1;
packed = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
const GFC_INTEGER_8 *src;
GFC_INTEGER_8 * restrict dest;
GFC_INTEGER_8 *destptr;
- int n;
int packed;
/* TODO: Investigate how we can figure out if this is a temporary
dim = GFC_DESCRIPTOR_RANK (source);
ssize = 1;
packed = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
const GFC_REAL_10 *src;
GFC_REAL_10 * restrict dest;
GFC_REAL_10 *destptr;
- int n;
int packed;
/* TODO: Investigate how we can figure out if this is a temporary
dim = GFC_DESCRIPTOR_RANK (source);
ssize = 1;
packed = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
const GFC_REAL_16 *src;
GFC_REAL_16 * restrict dest;
GFC_REAL_16 *destptr;
- int n;
int packed;
/* TODO: Investigate how we can figure out if this is a temporary
dim = GFC_DESCRIPTOR_RANK (source);
ssize = 1;
packed = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
const GFC_REAL_4 *src;
GFC_REAL_4 * restrict dest;
GFC_REAL_4 *destptr;
- int n;
int packed;
/* TODO: Investigate how we can figure out if this is a temporary
dim = GFC_DESCRIPTOR_RANK (source);
ssize = 1;
packed = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
const GFC_REAL_8 *src;
GFC_REAL_8 * restrict dest;
GFC_REAL_8 *destptr;
- int n;
int packed;
/* TODO: Investigate how we can figure out if this is a temporary
dim = GFC_DESCRIPTOR_RANK (source);
ssize = 1;
packed = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
index_type dsize;
GFC_COMPLEX_10 * restrict dest;
- int n;
dest = d->base_addr;
if (src == dest || !src)
dim = GFC_DESCRIPTOR_RANK (d);
dsize = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(d,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
index_type dsize;
GFC_COMPLEX_16 * restrict dest;
- int n;
dest = d->base_addr;
if (src == dest || !src)
dim = GFC_DESCRIPTOR_RANK (d);
dsize = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(d,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
index_type dsize;
GFC_COMPLEX_4 * restrict dest;
- int n;
dest = d->base_addr;
if (src == dest || !src)
dim = GFC_DESCRIPTOR_RANK (d);
dsize = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(d,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
index_type dsize;
GFC_COMPLEX_8 * restrict dest;
- int n;
dest = d->base_addr;
if (src == dest || !src)
dim = GFC_DESCRIPTOR_RANK (d);
dsize = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(d,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
index_type dsize;
GFC_INTEGER_1 * restrict dest;
- int n;
dest = d->base_addr;
if (src == dest || !src)
dim = GFC_DESCRIPTOR_RANK (d);
dsize = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(d,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
index_type dsize;
GFC_INTEGER_16 * restrict dest;
- int n;
dest = d->base_addr;
if (src == dest || !src)
dim = GFC_DESCRIPTOR_RANK (d);
dsize = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(d,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
index_type dsize;
GFC_INTEGER_2 * restrict dest;
- int n;
dest = d->base_addr;
if (src == dest || !src)
dim = GFC_DESCRIPTOR_RANK (d);
dsize = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(d,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
index_type dsize;
GFC_INTEGER_4 * restrict dest;
- int n;
dest = d->base_addr;
if (src == dest || !src)
dim = GFC_DESCRIPTOR_RANK (d);
dsize = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(d,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
index_type dsize;
GFC_INTEGER_8 * restrict dest;
- int n;
dest = d->base_addr;
if (src == dest || !src)
dim = GFC_DESCRIPTOR_RANK (d);
dsize = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(d,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
index_type dsize;
GFC_REAL_10 * restrict dest;
- int n;
dest = d->base_addr;
if (src == dest || !src)
dim = GFC_DESCRIPTOR_RANK (d);
dsize = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(d,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
index_type dsize;
GFC_REAL_16 * restrict dest;
- int n;
dest = d->base_addr;
if (src == dest || !src)
dim = GFC_DESCRIPTOR_RANK (d);
dsize = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(d,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
index_type dsize;
GFC_REAL_4 * restrict dest;
- int n;
dest = d->base_addr;
if (src == dest || !src)
dim = GFC_DESCRIPTOR_RANK (d);
dsize = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(d,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
index_type dsize;
GFC_REAL_8 * restrict dest;
- int n;
dest = d->base_addr;
if (src == dest || !src)
dim = GFC_DESCRIPTOR_RANK (d);
dsize = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(d,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
const GFC_COMPLEX_10 *pptr;
const GFC_COMPLEX_10 *src;
- int n;
- int dim;
int sempty, pempty, shape_empty;
index_type shape_data[GFC_MAX_DIMENSIONS];
shape_empty = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
index_type alloc_size;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rex = shape_data[n];
pdim = GFC_DESCRIPTOR_RANK (pad);
psize = 1;
pempty = 0;
- for (n = 0; n < pdim; n++)
+ for (index_type n = 0; n < pdim; n++)
{
pcount[n] = 0;
pstride[n] = GFC_DESCRIPTOR_STRIDE(pad,n);
index_type ret_extent, source_extent;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rs *= shape_data[n];
ret_extent = GFC_DESCRIPTOR_EXTENT(ret,n);
source_extent = 1;
sdim = GFC_DESCRIPTOR_RANK (source);
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
index_type se;
se = GFC_DESCRIPTOR_EXTENT(source,n);
int seen[GFC_MAX_DIMENSIONS];
index_type v;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
seen[n] = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
}
rsize = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
+ index_type dim;
if (order)
dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
ssize = 1;
sempty = 0;
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
scount[n] = 0;
sstride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src = pptr;
sptr = pptr;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
scount[0]++;
/* Advance to the next destination element. */
- n = 0;
+ index_type n = 0;
while (rcount[n] == rextent[n])
{
/* When we get to the end of a dimension, reset it and increment
/* Switch to the pad array. */
sptr = NULL;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
const GFC_COMPLEX_16 *pptr;
const GFC_COMPLEX_16 *src;
- int n;
- int dim;
int sempty, pempty, shape_empty;
index_type shape_data[GFC_MAX_DIMENSIONS];
shape_empty = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
index_type alloc_size;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rex = shape_data[n];
pdim = GFC_DESCRIPTOR_RANK (pad);
psize = 1;
pempty = 0;
- for (n = 0; n < pdim; n++)
+ for (index_type n = 0; n < pdim; n++)
{
pcount[n] = 0;
pstride[n] = GFC_DESCRIPTOR_STRIDE(pad,n);
index_type ret_extent, source_extent;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rs *= shape_data[n];
ret_extent = GFC_DESCRIPTOR_EXTENT(ret,n);
source_extent = 1;
sdim = GFC_DESCRIPTOR_RANK (source);
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
index_type se;
se = GFC_DESCRIPTOR_EXTENT(source,n);
int seen[GFC_MAX_DIMENSIONS];
index_type v;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
seen[n] = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
}
rsize = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
+ index_type dim;
if (order)
dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
ssize = 1;
sempty = 0;
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
scount[n] = 0;
sstride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src = pptr;
sptr = pptr;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
scount[0]++;
/* Advance to the next destination element. */
- n = 0;
+ index_type n = 0;
while (rcount[n] == rextent[n])
{
/* When we get to the end of a dimension, reset it and increment
/* Switch to the pad array. */
sptr = NULL;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
const GFC_COMPLEX_4 *pptr;
const GFC_COMPLEX_4 *src;
- int n;
- int dim;
int sempty, pempty, shape_empty;
index_type shape_data[GFC_MAX_DIMENSIONS];
shape_empty = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
index_type alloc_size;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rex = shape_data[n];
pdim = GFC_DESCRIPTOR_RANK (pad);
psize = 1;
pempty = 0;
- for (n = 0; n < pdim; n++)
+ for (index_type n = 0; n < pdim; n++)
{
pcount[n] = 0;
pstride[n] = GFC_DESCRIPTOR_STRIDE(pad,n);
index_type ret_extent, source_extent;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rs *= shape_data[n];
ret_extent = GFC_DESCRIPTOR_EXTENT(ret,n);
source_extent = 1;
sdim = GFC_DESCRIPTOR_RANK (source);
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
index_type se;
se = GFC_DESCRIPTOR_EXTENT(source,n);
int seen[GFC_MAX_DIMENSIONS];
index_type v;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
seen[n] = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
}
rsize = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
+ index_type dim;
if (order)
dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
ssize = 1;
sempty = 0;
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
scount[n] = 0;
sstride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src = pptr;
sptr = pptr;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
scount[0]++;
/* Advance to the next destination element. */
- n = 0;
+ index_type n = 0;
while (rcount[n] == rextent[n])
{
/* When we get to the end of a dimension, reset it and increment
/* Switch to the pad array. */
sptr = NULL;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
const GFC_COMPLEX_8 *pptr;
const GFC_COMPLEX_8 *src;
- int n;
- int dim;
int sempty, pempty, shape_empty;
index_type shape_data[GFC_MAX_DIMENSIONS];
shape_empty = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
index_type alloc_size;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rex = shape_data[n];
pdim = GFC_DESCRIPTOR_RANK (pad);
psize = 1;
pempty = 0;
- for (n = 0; n < pdim; n++)
+ for (index_type n = 0; n < pdim; n++)
{
pcount[n] = 0;
pstride[n] = GFC_DESCRIPTOR_STRIDE(pad,n);
index_type ret_extent, source_extent;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rs *= shape_data[n];
ret_extent = GFC_DESCRIPTOR_EXTENT(ret,n);
source_extent = 1;
sdim = GFC_DESCRIPTOR_RANK (source);
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
index_type se;
se = GFC_DESCRIPTOR_EXTENT(source,n);
int seen[GFC_MAX_DIMENSIONS];
index_type v;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
seen[n] = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
}
rsize = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
+ index_type dim;
if (order)
dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
ssize = 1;
sempty = 0;
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
scount[n] = 0;
sstride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src = pptr;
sptr = pptr;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
scount[0]++;
/* Advance to the next destination element. */
- n = 0;
+ index_type n = 0;
while (rcount[n] == rextent[n])
{
/* When we get to the end of a dimension, reset it and increment
/* Switch to the pad array. */
sptr = NULL;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
const GFC_INTEGER_16 *pptr;
const GFC_INTEGER_16 *src;
- int n;
- int dim;
int sempty, pempty, shape_empty;
index_type shape_data[GFC_MAX_DIMENSIONS];
shape_empty = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
index_type alloc_size;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rex = shape_data[n];
pdim = GFC_DESCRIPTOR_RANK (pad);
psize = 1;
pempty = 0;
- for (n = 0; n < pdim; n++)
+ for (index_type n = 0; n < pdim; n++)
{
pcount[n] = 0;
pstride[n] = GFC_DESCRIPTOR_STRIDE(pad,n);
index_type ret_extent, source_extent;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rs *= shape_data[n];
ret_extent = GFC_DESCRIPTOR_EXTENT(ret,n);
source_extent = 1;
sdim = GFC_DESCRIPTOR_RANK (source);
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
index_type se;
se = GFC_DESCRIPTOR_EXTENT(source,n);
int seen[GFC_MAX_DIMENSIONS];
index_type v;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
seen[n] = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
}
rsize = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
+ index_type dim;
if (order)
dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
ssize = 1;
sempty = 0;
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
scount[n] = 0;
sstride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src = pptr;
sptr = pptr;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
scount[0]++;
/* Advance to the next destination element. */
- n = 0;
+ index_type n = 0;
while (rcount[n] == rextent[n])
{
/* When we get to the end of a dimension, reset it and increment
/* Switch to the pad array. */
sptr = NULL;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
const GFC_INTEGER_4 *pptr;
const GFC_INTEGER_4 *src;
- int n;
- int dim;
int sempty, pempty, shape_empty;
index_type shape_data[GFC_MAX_DIMENSIONS];
shape_empty = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
index_type alloc_size;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rex = shape_data[n];
pdim = GFC_DESCRIPTOR_RANK (pad);
psize = 1;
pempty = 0;
- for (n = 0; n < pdim; n++)
+ for (index_type n = 0; n < pdim; n++)
{
pcount[n] = 0;
pstride[n] = GFC_DESCRIPTOR_STRIDE(pad,n);
index_type ret_extent, source_extent;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rs *= shape_data[n];
ret_extent = GFC_DESCRIPTOR_EXTENT(ret,n);
source_extent = 1;
sdim = GFC_DESCRIPTOR_RANK (source);
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
index_type se;
se = GFC_DESCRIPTOR_EXTENT(source,n);
int seen[GFC_MAX_DIMENSIONS];
index_type v;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
seen[n] = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
}
rsize = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
+ index_type dim;
if (order)
dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
ssize = 1;
sempty = 0;
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
scount[n] = 0;
sstride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src = pptr;
sptr = pptr;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
scount[0]++;
/* Advance to the next destination element. */
- n = 0;
+ index_type n = 0;
while (rcount[n] == rextent[n])
{
/* When we get to the end of a dimension, reset it and increment
/* Switch to the pad array. */
sptr = NULL;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
const GFC_INTEGER_8 *pptr;
const GFC_INTEGER_8 *src;
- int n;
- int dim;
int sempty, pempty, shape_empty;
index_type shape_data[GFC_MAX_DIMENSIONS];
shape_empty = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
index_type alloc_size;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rex = shape_data[n];
pdim = GFC_DESCRIPTOR_RANK (pad);
psize = 1;
pempty = 0;
- for (n = 0; n < pdim; n++)
+ for (index_type n = 0; n < pdim; n++)
{
pcount[n] = 0;
pstride[n] = GFC_DESCRIPTOR_STRIDE(pad,n);
index_type ret_extent, source_extent;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rs *= shape_data[n];
ret_extent = GFC_DESCRIPTOR_EXTENT(ret,n);
source_extent = 1;
sdim = GFC_DESCRIPTOR_RANK (source);
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
index_type se;
se = GFC_DESCRIPTOR_EXTENT(source,n);
int seen[GFC_MAX_DIMENSIONS];
index_type v;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
seen[n] = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
}
rsize = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
+ index_type dim;
if (order)
dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
ssize = 1;
sempty = 0;
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
scount[n] = 0;
sstride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src = pptr;
sptr = pptr;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
scount[0]++;
/* Advance to the next destination element. */
- n = 0;
+ index_type n = 0;
while (rcount[n] == rextent[n])
{
/* When we get to the end of a dimension, reset it and increment
/* Switch to the pad array. */
sptr = NULL;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
const GFC_REAL_10 *pptr;
const GFC_REAL_10 *src;
- int n;
- int dim;
int sempty, pempty, shape_empty;
index_type shape_data[GFC_MAX_DIMENSIONS];
shape_empty = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
index_type alloc_size;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rex = shape_data[n];
pdim = GFC_DESCRIPTOR_RANK (pad);
psize = 1;
pempty = 0;
- for (n = 0; n < pdim; n++)
+ for (index_type n = 0; n < pdim; n++)
{
pcount[n] = 0;
pstride[n] = GFC_DESCRIPTOR_STRIDE(pad,n);
index_type ret_extent, source_extent;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rs *= shape_data[n];
ret_extent = GFC_DESCRIPTOR_EXTENT(ret,n);
source_extent = 1;
sdim = GFC_DESCRIPTOR_RANK (source);
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
index_type se;
se = GFC_DESCRIPTOR_EXTENT(source,n);
int seen[GFC_MAX_DIMENSIONS];
index_type v;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
seen[n] = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
}
rsize = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
+ index_type dim;
if (order)
dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
ssize = 1;
sempty = 0;
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
scount[n] = 0;
sstride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src = pptr;
sptr = pptr;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
scount[0]++;
/* Advance to the next destination element. */
- n = 0;
+ index_type n = 0;
while (rcount[n] == rextent[n])
{
/* When we get to the end of a dimension, reset it and increment
/* Switch to the pad array. */
sptr = NULL;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
const GFC_REAL_16 *pptr;
const GFC_REAL_16 *src;
- int n;
- int dim;
int sempty, pempty, shape_empty;
index_type shape_data[GFC_MAX_DIMENSIONS];
shape_empty = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
index_type alloc_size;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rex = shape_data[n];
pdim = GFC_DESCRIPTOR_RANK (pad);
psize = 1;
pempty = 0;
- for (n = 0; n < pdim; n++)
+ for (index_type n = 0; n < pdim; n++)
{
pcount[n] = 0;
pstride[n] = GFC_DESCRIPTOR_STRIDE(pad,n);
index_type ret_extent, source_extent;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rs *= shape_data[n];
ret_extent = GFC_DESCRIPTOR_EXTENT(ret,n);
source_extent = 1;
sdim = GFC_DESCRIPTOR_RANK (source);
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
index_type se;
se = GFC_DESCRIPTOR_EXTENT(source,n);
int seen[GFC_MAX_DIMENSIONS];
index_type v;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
seen[n] = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
}
rsize = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
+ index_type dim;
if (order)
dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
ssize = 1;
sempty = 0;
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
scount[n] = 0;
sstride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src = pptr;
sptr = pptr;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
scount[0]++;
/* Advance to the next destination element. */
- n = 0;
+ index_type n = 0;
while (rcount[n] == rextent[n])
{
/* When we get to the end of a dimension, reset it and increment
/* Switch to the pad array. */
sptr = NULL;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
const GFC_REAL_4 *pptr;
const GFC_REAL_4 *src;
- int n;
- int dim;
int sempty, pempty, shape_empty;
index_type shape_data[GFC_MAX_DIMENSIONS];
shape_empty = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
index_type alloc_size;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rex = shape_data[n];
pdim = GFC_DESCRIPTOR_RANK (pad);
psize = 1;
pempty = 0;
- for (n = 0; n < pdim; n++)
+ for (index_type n = 0; n < pdim; n++)
{
pcount[n] = 0;
pstride[n] = GFC_DESCRIPTOR_STRIDE(pad,n);
index_type ret_extent, source_extent;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rs *= shape_data[n];
ret_extent = GFC_DESCRIPTOR_EXTENT(ret,n);
source_extent = 1;
sdim = GFC_DESCRIPTOR_RANK (source);
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
index_type se;
se = GFC_DESCRIPTOR_EXTENT(source,n);
int seen[GFC_MAX_DIMENSIONS];
index_type v;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
seen[n] = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
}
rsize = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
+ index_type dim;
if (order)
dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
ssize = 1;
sempty = 0;
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
scount[n] = 0;
sstride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src = pptr;
sptr = pptr;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
scount[0]++;
/* Advance to the next destination element. */
- n = 0;
+ index_type n = 0;
while (rcount[n] == rextent[n])
{
/* When we get to the end of a dimension, reset it and increment
/* Switch to the pad array. */
sptr = NULL;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
const GFC_REAL_8 *pptr;
const GFC_REAL_8 *src;
- int n;
- int dim;
int sempty, pempty, shape_empty;
index_type shape_data[GFC_MAX_DIMENSIONS];
shape_empty = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
index_type alloc_size;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rex = shape_data[n];
pdim = GFC_DESCRIPTOR_RANK (pad);
psize = 1;
pempty = 0;
- for (n = 0; n < pdim; n++)
+ for (index_type n = 0; n < pdim; n++)
{
pcount[n] = 0;
pstride[n] = GFC_DESCRIPTOR_STRIDE(pad,n);
index_type ret_extent, source_extent;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rs *= shape_data[n];
ret_extent = GFC_DESCRIPTOR_EXTENT(ret,n);
source_extent = 1;
sdim = GFC_DESCRIPTOR_RANK (source);
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
index_type se;
se = GFC_DESCRIPTOR_EXTENT(source,n);
int seen[GFC_MAX_DIMENSIONS];
index_type v;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
seen[n] = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
}
rsize = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
+ index_type dim;
if (order)
dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
ssize = 1;
sempty = 0;
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
scount[n] = 0;
sstride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src = pptr;
sptr = pptr;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
scount[0]++;
/* Advance to the next destination element. */
- n = 0;
+ index_type n = 0;
while (rcount[n] == rextent[n])
{
/* When we get to the end of a dimension, reset it and increment
/* Switch to the pad array. */
sptr = NULL;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
shape_1 (gfc_array_i1 * const restrict ret,
const array_t * const restrict array)
{
- int n;
index_type stride;
index_type extent;
- int rank;
- rank = GFC_DESCRIPTOR_RANK (array);
+ int rank = GFC_DESCRIPTOR_RANK (array);
if (ret->base_addr == NULL)
{
if (GFC_DESCRIPTOR_EXTENT(ret,0) < 1)
return;
- for (n = 0; n < rank; n++)
+ for (index_type n = 0; n < rank; n++)
{
extent = GFC_DESCRIPTOR_EXTENT(array,n);
ret->base_addr[n * stride] = extent > 0 ? extent : 0 ;
shape_16 (gfc_array_i16 * const restrict ret,
const array_t * const restrict array)
{
- int n;
index_type stride;
index_type extent;
- int rank;
- rank = GFC_DESCRIPTOR_RANK (array);
+ int rank = GFC_DESCRIPTOR_RANK (array);
if (ret->base_addr == NULL)
{
if (GFC_DESCRIPTOR_EXTENT(ret,0) < 1)
return;
- for (n = 0; n < rank; n++)
+ for (index_type n = 0; n < rank; n++)
{
extent = GFC_DESCRIPTOR_EXTENT(array,n);
ret->base_addr[n * stride] = extent > 0 ? extent : 0 ;
shape_2 (gfc_array_i2 * const restrict ret,
const array_t * const restrict array)
{
- int n;
index_type stride;
index_type extent;
- int rank;
- rank = GFC_DESCRIPTOR_RANK (array);
+ int rank = GFC_DESCRIPTOR_RANK (array);
if (ret->base_addr == NULL)
{
if (GFC_DESCRIPTOR_EXTENT(ret,0) < 1)
return;
- for (n = 0; n < rank; n++)
+ for (index_type n = 0; n < rank; n++)
{
extent = GFC_DESCRIPTOR_EXTENT(array,n);
ret->base_addr[n * stride] = extent > 0 ? extent : 0 ;
shape_4 (gfc_array_i4 * const restrict ret,
const array_t * const restrict array)
{
- int n;
index_type stride;
index_type extent;
- int rank;
- rank = GFC_DESCRIPTOR_RANK (array);
+ int rank = GFC_DESCRIPTOR_RANK (array);
if (ret->base_addr == NULL)
{
if (GFC_DESCRIPTOR_EXTENT(ret,0) < 1)
return;
- for (n = 0; n < rank; n++)
+ for (index_type n = 0; n < rank; n++)
{
extent = GFC_DESCRIPTOR_EXTENT(array,n);
ret->base_addr[n * stride] = extent > 0 ? extent : 0 ;
shape_8 (gfc_array_i8 * const restrict ret,
const array_t * const restrict array)
{
- int n;
index_type stride;
index_type extent;
- int rank;
- rank = GFC_DESCRIPTOR_RANK (array);
+ int rank = GFC_DESCRIPTOR_RANK (array);
if (ret->base_addr == NULL)
{
if (GFC_DESCRIPTOR_EXTENT(ret,0) < 1)
return;
- for (n = 0; n < rank; n++)
+ for (index_type n = 0; n < rank; n++)
{
extent = GFC_DESCRIPTOR_EXTENT(array,n);
ret->base_addr[n * stride] = extent > 0 ? extent : 0 ;
void
spread_scalar_c10 (gfc_array_c10 *ret, const GFC_COMPLEX_10 *source,
- const index_type along, const index_type pncopies)
+ const index_type along, const index_type ncopies)
{
- int n;
- int ncopies = pncopies;
GFC_COMPLEX_10 * restrict dest;
index_type stride;
dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- for (n = 0; n < ncopies; n++)
+ for (index_type n = 0; n < ncopies; n++)
{
*dest = *source;
dest += stride;
void
spread_scalar_c16 (gfc_array_c16 *ret, const GFC_COMPLEX_16 *source,
- const index_type along, const index_type pncopies)
+ const index_type along, const index_type ncopies)
{
- int n;
- int ncopies = pncopies;
GFC_COMPLEX_16 * restrict dest;
index_type stride;
dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- for (n = 0; n < ncopies; n++)
+ for (index_type n = 0; n < ncopies; n++)
{
*dest = *source;
dest += stride;
void
spread_scalar_c4 (gfc_array_c4 *ret, const GFC_COMPLEX_4 *source,
- const index_type along, const index_type pncopies)
+ const index_type along, const index_type ncopies)
{
- int n;
- int ncopies = pncopies;
GFC_COMPLEX_4 * restrict dest;
index_type stride;
dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- for (n = 0; n < ncopies; n++)
+ for (index_type n = 0; n < ncopies; n++)
{
*dest = *source;
dest += stride;
void
spread_scalar_c8 (gfc_array_c8 *ret, const GFC_COMPLEX_8 *source,
- const index_type along, const index_type pncopies)
+ const index_type along, const index_type ncopies)
{
- int n;
- int ncopies = pncopies;
GFC_COMPLEX_8 * restrict dest;
index_type stride;
dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- for (n = 0; n < ncopies; n++)
+ for (index_type n = 0; n < ncopies; n++)
{
*dest = *source;
dest += stride;
void
spread_scalar_i1 (gfc_array_i1 *ret, const GFC_INTEGER_1 *source,
- const index_type along, const index_type pncopies)
+ const index_type along, const index_type ncopies)
{
- int n;
- int ncopies = pncopies;
GFC_INTEGER_1 * restrict dest;
index_type stride;
dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- for (n = 0; n < ncopies; n++)
+ for (index_type n = 0; n < ncopies; n++)
{
*dest = *source;
dest += stride;
void
spread_scalar_i16 (gfc_array_i16 *ret, const GFC_INTEGER_16 *source,
- const index_type along, const index_type pncopies)
+ const index_type along, const index_type ncopies)
{
- int n;
- int ncopies = pncopies;
GFC_INTEGER_16 * restrict dest;
index_type stride;
dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- for (n = 0; n < ncopies; n++)
+ for (index_type n = 0; n < ncopies; n++)
{
*dest = *source;
dest += stride;
void
spread_scalar_i2 (gfc_array_i2 *ret, const GFC_INTEGER_2 *source,
- const index_type along, const index_type pncopies)
+ const index_type along, const index_type ncopies)
{
- int n;
- int ncopies = pncopies;
GFC_INTEGER_2 * restrict dest;
index_type stride;
dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- for (n = 0; n < ncopies; n++)
+ for (index_type n = 0; n < ncopies; n++)
{
*dest = *source;
dest += stride;
void
spread_scalar_i4 (gfc_array_i4 *ret, const GFC_INTEGER_4 *source,
- const index_type along, const index_type pncopies)
+ const index_type along, const index_type ncopies)
{
- int n;
- int ncopies = pncopies;
GFC_INTEGER_4 * restrict dest;
index_type stride;
dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- for (n = 0; n < ncopies; n++)
+ for (index_type n = 0; n < ncopies; n++)
{
*dest = *source;
dest += stride;
void
spread_scalar_i8 (gfc_array_i8 *ret, const GFC_INTEGER_8 *source,
- const index_type along, const index_type pncopies)
+ const index_type along, const index_type ncopies)
{
- int n;
- int ncopies = pncopies;
GFC_INTEGER_8 * restrict dest;
index_type stride;
dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- for (n = 0; n < ncopies; n++)
+ for (index_type n = 0; n < ncopies; n++)
{
*dest = *source;
dest += stride;
void
spread_scalar_r10 (gfc_array_r10 *ret, const GFC_REAL_10 *source,
- const index_type along, const index_type pncopies)
+ const index_type along, const index_type ncopies)
{
- int n;
- int ncopies = pncopies;
GFC_REAL_10 * restrict dest;
index_type stride;
dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- for (n = 0; n < ncopies; n++)
+ for (index_type n = 0; n < ncopies; n++)
{
*dest = *source;
dest += stride;
void
spread_scalar_r16 (gfc_array_r16 *ret, const GFC_REAL_16 *source,
- const index_type along, const index_type pncopies)
+ const index_type along, const index_type ncopies)
{
- int n;
- int ncopies = pncopies;
GFC_REAL_16 * restrict dest;
index_type stride;
dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- for (n = 0; n < ncopies; n++)
+ for (index_type n = 0; n < ncopies; n++)
{
*dest = *source;
dest += stride;
void
spread_scalar_r4 (gfc_array_r4 *ret, const GFC_REAL_4 *source,
- const index_type along, const index_type pncopies)
+ const index_type along, const index_type ncopies)
{
- int n;
- int ncopies = pncopies;
GFC_REAL_4 * restrict dest;
index_type stride;
dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- for (n = 0; n < ncopies; n++)
+ for (index_type n = 0; n < ncopies; n++)
{
*dest = *source;
dest += stride;
void
spread_scalar_r8 (gfc_array_r8 *ret, const GFC_REAL_8 *source,
- const index_type along, const index_type pncopies)
+ const index_type along, const index_type ncopies)
{
- int n;
- int ncopies = pncopies;
GFC_REAL_8 * restrict dest;
index_type stride;
dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- for (n = 0; n < ncopies; n++)
+ for (index_type n = 0; n < ncopies; n++)
{
*dest = *source;
dest += stride;
};
uint64_t t[16] = { 0 };
- for(unsigned int i = 0; i < sizeof JUMP / sizeof *JUMP; i++)
+ for(size_t i = 0; i < sizeof JUMP / sizeof *JUMP; i++)
for(int b = 0; b < 64; b++)
{
if (JUMP[i] & 1ULL << b)
/* rand_s is available in MinGW-w64 but not plain MinGW. */
#if defined(__MINGW64_VERSION_MAJOR)
unsigned int* b = buf;
- for (unsigned i = 0; i < buflen / sizeof (unsigned int); i++)
+ for (size_t i = 0; i < buflen / sizeof (unsigned int); i++)
rand_s (&b[i]);
return buflen;
#else
index_type dim;
GFC_REAL_4 *dest;
xorshift1024star_state* rs = get_rand_state();
- int n;
-
dest = x->base_addr;
dim = GFC_DESCRIPTOR_RANK (x);
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(x,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
GFC_REAL_8 *dest;
xorshift1024star_state* rs = get_rand_state();
- int n;
dest = x->base_addr;
dim = GFC_DESCRIPTOR_RANK (x);
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(x,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
GFC_REAL_10 *dest;
xorshift1024star_state* rs = get_rand_state();
- int n;
dest = x->base_addr;
dim = GFC_DESCRIPTOR_RANK (x);
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(x,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
GFC_REAL_16 *dest;
xorshift1024star_state* rs = get_rand_state();
- int n;
dest = x->base_addr;
dim = GFC_DESCRIPTOR_RANK (x);
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(x,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
static void
scramble_seed (uint64_t *dest, const uint64_t *src)
{
- for (int i = 0; i < (int) SZU64; i++)
+ for (size_t i = 0; i < SZU64; i++)
dest[i] = src[i] ^ xor_keys[i];
}
if (ret->base_addr == NULL)
{
- int i;
-
ret->base_addr = xmallocarray (arraysize, size);
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
- for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
+ for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
index_type ub, str;
arraysize = size0 ((array_t *) array);
if (ret->base_addr == NULL)
{
- int i;
-
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
- for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
+ for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
index_type ub, str;
if (ret->base_addr == NULL)
{
- int i;
-
ret->base_addr = xmallocarray (arraysize, size);
ret->offset = 0;
GFC_DTYPE_COPY(ret,array);
- for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
+ for (index_type i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
{
index_type ub, str;
const 'rtype_name` *src;
'rtype_name` * restrict dest;
'rtype_name` *destptr;
- int n;
int packed;
/* TODO: Investigate how we can figure out if this is a temporary
dim = GFC_DESCRIPTOR_RANK (source);
ssize = 1;
packed = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dim;
index_type dsize;
'rtype_name` * restrict dest;
- int n;
dest = d->base_addr;
if (src == dest || !src)
dim = GFC_DESCRIPTOR_RANK (d);
dsize = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(d,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
const 'rtype_name` *pptr;
const 'rtype_name` *src;
- int n;
- int dim;
int sempty, pempty, shape_empty;
index_type shape_data[GFC_MAX_DIMENSIONS];
shape_empty = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
index_type alloc_size;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rex = shape_data[n];
pdim = GFC_DESCRIPTOR_RANK (pad);
psize = 1;
pempty = 0;
- for (n = 0; n < pdim; n++)
+ for (index_type n = 0; n < pdim; n++)
{
pcount[n] = 0;
pstride[n] = GFC_DESCRIPTOR_STRIDE(pad,n);
index_type ret_extent, source_extent;
rs = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
rs *= shape_data[n];
ret_extent = GFC_DESCRIPTOR_EXTENT(ret,n);
source_extent = 1;
sdim = GFC_DESCRIPTOR_RANK (source);
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
index_type se;
se = GFC_DESCRIPTOR_EXTENT(source,n);
int seen[GFC_MAX_DIMENSIONS];
index_type v;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
seen[n] = 0;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
}
rsize = 1;
- for (n = 0; n < rdim; n++)
+ for (index_type n = 0; n < rdim; n++)
{
+ index_type dim;
if (order)
dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
ssize = 1;
sempty = 0;
- for (n = 0; n < sdim; n++)
+ for (index_type n = 0; n < sdim; n++)
{
scount[n] = 0;
sstride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src = pptr;
sptr = pptr;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
scount[0]++;
/* Advance to the next destination element. */
- n = 0;
+ index_type n = 0;
while (rcount[n] == rextent[n])
{
/* When we get to the end of a dimension, reset it and increment
/* Switch to the pad array. */
sptr = NULL;
sdim = pdim;
- for (dim = 0; dim < pdim; dim++)
+ for (index_type dim = 0; dim < pdim; dim++)
{
scount[dim] = pcount[dim];
sextent[dim] = pextent[dim];
shape_'rtype_kind` ('rtype` * const restrict ret,
const array_t * const restrict array)
{
- int n;
index_type stride;
index_type extent;
- int rank;
- rank = GFC_DESCRIPTOR_RANK (array);
+ int rank = GFC_DESCRIPTOR_RANK (array);
if (ret->base_addr == NULL)
{
if (GFC_DESCRIPTOR_EXTENT(ret,0) < 1)
return;
- for (n = 0; n < rank; n++)
+ for (index_type n = 0; n < rank; n++)
{
extent = GFC_DESCRIPTOR_EXTENT(array,n);
ret->base_addr[n * stride] = extent > 0 ? extent : 0 ;
void
spread_scalar_'rtype_code` ('rtype` *ret, const 'rtype_name` *source,
- const index_type along, const index_type pncopies)
+ const index_type along, const index_type ncopies)
{
- int n;
- int ncopies = pncopies;
'rtype_name` * restrict dest;
index_type stride;
dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- for (n = 0; n < ncopies; n++)
+ for (index_type n = 0; n < ncopies; n++)
{
*dest = *source;
dest += stride;
const char * a_name, const char * intrinsic)
{
int empty;
- int n;
int rank;
index_type a_size;
a_size = size0 (a);
empty = 0;
- for (n = 0; n < rank; n++)
+ for (index_type n = 0; n < rank; n++)
{
if (extent[n] == 0)
empty = 1;
" intrinsic: should not be zero-sized",
a_name, intrinsic);
- for (n = 0; n < rank; n++)
+ for (index_type n = 0; n < rank; n++)
{
index_type a_extent;
a_extent = GFC_DESCRIPTOR_EXTENT(a, n);
const char *src;
char *dest;
void *destptr;
- int n;
int packed;
index_type size;
index_type type_size;
dim = GFC_DESCRIPTOR_RANK (source);
ssize = 1;
packed = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(source,n);
src += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
index_type dsize;
char *dest;
const char *src;
- int n;
- int size;
+ index_type size;
int type_size;
dest = d->base_addr;
dim = GFC_DESCRIPTOR_RANK (d);
dsize = 1;
- for (n = 0; n < dim; n++)
+ for (index_type n = 0; n < dim; n++)
{
count[n] = 0;
stride[n] = GFC_DESCRIPTOR_STRIDE(d,n);
dest += stride0;
count[0]++;
/* Advance to the next source element. */
- n = 0;
+ index_type n = 0;
while (count[n] == extent[n])
{
/* When we get to the end of a dimension, reset it and increment
projects / gcc.git / commitdiff