+2006-12-30 Thomas Koenig <Thomas.Koenig@online.de>
+
+ PR libfortran/30321
+ * gfortran.dg/sum_zero_array_1.f90: New test.
+
2006-12-29 Jakub Jelinek <jakub@redhat.com>
PR preprocessor/29612
--- /dev/null
+! { dg-do run }
+! PR 30321: This used to segfault.
+program xzero
+ implicit none
+ integer :: ii(1,0)
+ logical :: ll(1,0)
+ character (len=80) line
+ ll = .true.
+ write (unit=line, fmt="(I6)") sum(ii,dim=1)
+ if (line /= " ") call abort
+ write (unit=line, fmt="(I6)") sum(ii,dim=1,mask=ll)
+ if (line /= " ") call abort
+end program xzero
+2006-12-30 Thomas Koenig <Thomas.Koenig@online.de>
+
+ PR libfortran/30321
+ * m4/ifunction.m4 (name`'rtype_qual`_'atype_code):
+ Check for extents < 0 for zero-sized arrays. If
+ no retarray has been specified and the size is zero,
+ return early.
+ (`m'name`'rtype_qual`_'atype_code): Likewise.
+ * generated/all_l16.c: Regenerated.
+ * generated/all_l4.c: Regenerated.
+ * generated/all_l8.c: Regenerated.
+ * generated/any_l16.c: Regenerated.
+ * generated/any_l4.c: Regenerated.
+ * generated/any_l8.c: Regenerated.
+ * generated/count_16_l16.c: Regenerated.
+ * generated/count_16_l4.c: Regenerated.
+ * generated/count_16_l8.c: Regenerated.
+ * generated/count_4_l16.c: Regenerated.
+ * generated/count_4_l4.c: Regenerated.
+ * generated/count_4_l8.c: Regenerated.
+ * generated/count_8_l16.c: Regenerated.
+ * generated/count_8_l4.c: Regenerated.
+ * generated/count_8_l8.c: Regenerated.
+ * generated/cshift1_16.c: Regenerated.
+ * generated/cshift1_4.c: Regenerated.
+ * generated/cshift1_8.c: Regenerated.
+ * generated/maxloc1_16_i16.c: Regenerated.
+ * generated/maxloc1_16_i4.c: Regenerated.
+ * generated/maxloc1_16_i8.c: Regenerated.
+ * generated/maxloc1_16_r10.c: Regenerated.
+ * generated/maxloc1_16_r16.c: Regenerated.
+ * generated/maxloc1_16_r4.c: Regenerated.
+ * generated/maxloc1_16_r8.c: Regenerated.
+ * generated/maxloc1_4_i16.c: Regenerated.
+ * generated/maxloc1_4_i4.c: Regenerated.
+ * generated/maxloc1_4_i8.c: Regenerated.
+ * generated/maxloc1_4_r10.c: Regenerated.
+ * generated/maxloc1_4_r16.c: Regenerated.
+ * generated/maxloc1_4_r4.c: Regenerated.
+ * generated/maxloc1_4_r8.c: Regenerated.
+ * generated/maxloc1_8_i16.c: Regenerated.
+ * generated/maxloc1_8_i4.c: Regenerated.
+ * generated/maxloc1_8_i8.c: Regenerated.
+ * generated/maxloc1_8_r10.c: Regenerated.
+ * generated/maxloc1_8_r16.c: Regenerated.
+ * generated/maxloc1_8_r4.c: Regenerated.
+ * generated/maxloc1_8_r8.c: Regenerated.
+ * generated/maxval_i16.c: Regenerated.
+ * generated/maxval_i4.c: Regenerated.
+ * generated/maxval_i8.c: Regenerated.
+ * generated/maxval_r10.c: Regenerated.
+ * generated/maxval_r16.c: Regenerated.
+ * generated/maxval_r4.c: Regenerated.
+ * generated/maxval_r8.c: Regenerated.
+ * generated/minloc1_16_i16.c: Regenerated.
+ * generated/minloc1_16_i4.c: Regenerated.
+ * generated/minloc1_16_i8.c: Regenerated.
+ * generated/minloc1_16_r10.c: Regenerated.
+ * generated/minloc1_16_r16.c: Regenerated.
+ * generated/minloc1_16_r4.c: Regenerated.
+ * generated/minloc1_16_r8.c: Regenerated.
+ * generated/minloc1_4_i16.c: Regenerated.
+ * generated/minloc1_4_i4.c: Regenerated.
+ * generated/minloc1_4_i8.c: Regenerated.
+ * generated/minloc1_4_r10.c: Regenerated.
+ * generated/minloc1_4_r16.c: Regenerated.
+ * generated/minloc1_4_r4.c: Regenerated.
+ * generated/minloc1_4_r8.c: Regenerated.
+ * generated/minloc1_8_i16.c: Regenerated.
+ * generated/minloc1_8_i4.c: Regenerated.
+ * generated/minloc1_8_i8.c: Regenerated.
+ * generated/minloc1_8_r10.c: Regenerated.
+ * generated/minloc1_8_r16.c: Regenerated.
+ * generated/minloc1_8_r4.c: Regenerated.
+ * generated/minloc1_8_r8.c: Regenerated.
+ * generated/minval_i16.c: Regenerated.
+ * generated/minval_i4.c: Regenerated.
+ * generated/minval_i8.c: Regenerated.
+ * generated/minval_r10.c: Regenerated.
+ * generated/minval_r16.c: Regenerated.
+ * generated/minval_r4.c: Regenerated.
+ * generated/minval_r8.c: Regenerated.
+ * generated/product_c10.c: Regenerated.
+ * generated/product_c16.c: Regenerated.
+ * generated/product_c4.c: Regenerated.
+ * generated/product_c8.c: Regenerated.
+ * generated/product_i16.c: Regenerated.
+ * generated/product_i4.c: Regenerated.
+ * generated/product_i8.c: Regenerated.
+ * generated/product_r10.c: Regenerated.
+ * generated/product_r16.c: Regenerated.
+ * generated/product_r4.c: Regenerated.
+ * generated/product_r8.c: Regenerated.
+ * generated/sum_c10.c: Regenerated.
+ * generated/sum_c16.c: Regenerated.
+ * generated/sum_c4.c: Regenerated.
+ * generated/sum_c8.c: Regenerated.
+ * generated/sum_i16.c: Regenerated.
+ * generated/sum_i4.c: Regenerated.
+ * generated/sum_i8.c: Regenerated.
+ * generated/sum_r10.c: Regenerated.
+ * generated/sum_r16.c: Regenerated.
+ * generated/sum_r4.c: Regenerated.
+ * generated/sum_r8.c: Regenerated.
+
2006-12-27 Jerry DeLisle <jvdelisle@gcc.gnu.org>
PR libgfortran/30014
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_LOGICAL_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_LOGICAL_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_LOGICAL_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_LOGICAL_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_LOGICAL_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_LOGICAL_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_LOGICAL_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_LOGICAL_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_LOGICAL_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_LOGICAL_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_LOGICAL_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_LOGICAL_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
index_type soffset;
const char *sptr;
const char *src;
- /* h.* indicates the array. */
+ /* h.* indicates the shift array. */
index_type hstride[GFC_MAX_DIMENSIONS];
index_type hstride0;
const GFC_INTEGER_16 *hptr;
while (rptr)
{
- /* Do the for this dimension. */
+ /* Do the shift for this dimension. */
sh = *hptr;
sh = (div (sh, len)).rem;
if (sh < 0)
index_type soffset;
const char *sptr;
const char *src;
- /* h.* indicates the array. */
+ /* h.* indicates the shift array. */
index_type hstride[GFC_MAX_DIMENSIONS];
index_type hstride0;
const GFC_INTEGER_4 *hptr;
while (rptr)
{
- /* Do the for this dimension. */
+ /* Do the shift for this dimension. */
sh = *hptr;
sh = (div (sh, len)).rem;
if (sh < 0)
index_type soffset;
const char *sptr;
const char *src;
- /* h.* indicates the array. */
+ /* h.* indicates the shift array. */
index_type hstride[GFC_MAX_DIMENSIONS];
index_type hstride0;
const GFC_INTEGER_8 *hptr;
while (rptr)
{
- /* Do the for this dimension. */
+ /* Do the shift for this dimension. */
sh = *hptr;
sh = (div (sh, len)).rem;
if (sh < 0)
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_10)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_10)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_REAL_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_REAL_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_REAL_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_REAL_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_REAL_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_REAL_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_10)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_10)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_REAL_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_REAL_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_REAL_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_REAL_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_REAL_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_REAL_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_COMPLEX_10)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_COMPLEX_10) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_COMPLEX_10)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_COMPLEX_10) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_COMPLEX_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_COMPLEX_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_COMPLEX_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_COMPLEX_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_COMPLEX_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_COMPLEX_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_COMPLEX_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_COMPLEX_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_COMPLEX_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_COMPLEX_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_COMPLEX_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_COMPLEX_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_10)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_10)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_REAL_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_REAL_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_REAL_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_REAL_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_REAL_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_REAL_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_COMPLEX_10)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_COMPLEX_10) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_COMPLEX_10)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_COMPLEX_10) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_COMPLEX_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_COMPLEX_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_COMPLEX_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_COMPLEX_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_COMPLEX_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_COMPLEX_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_COMPLEX_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_COMPLEX_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_COMPLEX_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_COMPLEX_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_COMPLEX_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_COMPLEX_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_INTEGER_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_INTEGER_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_10)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_10)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_REAL_10) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_REAL_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_16)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_REAL_16) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_REAL_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_4)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_REAL_4) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (GFC_REAL_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (GFC_REAL_8)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (GFC_REAL_8) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
{
sstride[n] = array->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
for (n = dim; n < rank; n++)
{
sstride[n] = array->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (rtype_name)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ alloc_size = sizeof (rtype_name) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
}
else
{
sstride[n] = array->dim[n].stride;
mstride[n] = mask->dim[n].stride;
extent[n] = array->dim[n].ubound + 1 - array->dim[n].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
+
}
for (n = dim; n < rank; n++)
{
mstride[n] = mask->dim[n + 1].stride;
extent[n] =
array->dim[n + 1].ubound + 1 - array->dim[n + 1].lbound;
+
+ if (extent[n] < 0)
+ extent[n] = 0;
}
if (retarray->data == NULL)
{
+ size_t alloc_size;
+
for (n = 0; n < rank; n++)
{
retarray->dim[n].lbound = 0;
retarray->dim[n].stride = retarray->dim[n-1].stride * extent[n-1];
}
- retarray->data
- = internal_malloc_size (sizeof (rtype_name)
- * retarray->dim[rank-1].stride
- * extent[rank-1]);
+ alloc_size = sizeof (rtype_name) * retarray->dim[rank-1].stride
+ * extent[rank-1];
+
retarray->offset = 0;
retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
+
+ if (alloc_size == 0)
+ {
+ /* Make sure we have a zero-sized array. */
+ retarray->dim[0].lbound = 0;
+ retarray->dim[0].ubound = -1;
+ return;
+ }
+ else
+ retarray->data = internal_malloc_size (alloc_size);
+
}
else
{
projects / platform / upstream / linaro-gcc.git / commitdiff