+2012-03-10 Tobias Burnus <burnus@net-b.de>
+
+ * libgfortran.h (descriptor_dimension, GFC_DIMENSION_LBOUND,
+ GFC_DIMENSION_EXTENT, GFC_DIMENSION_SET, GFC_DESCRIPTOR_DATA,
+ GFC_ARRAY_DESCRIPTOR): Rename _lbound to lower_bound and
+ data to base_addr.
+ * intrinsics/cshift0.c (size0, cshift0): Handle data to
+ base_addr rename.
+ * intrinsics/date_and_time.c (date_and_time, secnds, itime_i4,
+ itime_i8, gmtime_i4, gmtime_i8, ltime_i4, ltime_i8): Ditto.
+ * intrinsics/dtime.c (dtime_sub): Ditto.
+ * intrinsics/eoshift0.c (eoshift0): Ditto.
+ * intrinsics/eoshift2.c (eoshift2): Ditto.
+ * intrinsics/etime.c (etime_sub): Ditto.
+ * intrinsics/iso_c_binding.c (c_f_pointer_u0): Ditto.
+ * intrinsics/move_alloc.c (move_alloc): Ditto.
+ * intrinsics/pack_generic.c (pack_internal, pack,
+ pack_s_internal): Ditto.
+ * intrinsics/random.c (arandom_r4, arandom_r8, arandom_r10,
+ arandom_r16, random_seed_i4, random_seed_i8): Ditto.
+ * intrinsics/reshape_generic.c (reshape_internal): Ditto.
+ * intrinsics/spread_generic.c (spread_internal,
+ spread_internal_scalar, spread, spread_scalar): Ditto.
+ * intrinsics/stat.c (stat_i4_sub_0, stat_i8_sub_0, fstat_i4_sub,
+ fstat_i8_sub): Ditto.
+ * intrinsics/transpose_generic.c (transpose_internal): Ditto.
+ * intrinsics/unpack_generic.c (unpack_bounds, unpack_internal,
+ unpack1, unpack0, unpack0_char4): Ditto.
+ * m4/bessel.m4 (bessel_jn_r'rtype_kind`, bessel_yn_r'rtype_kind`):
+ Ditto.
+ * m4/cshift0.m4 (cshift0_'rtype_code`): Ditto.
+ * m4/cshift1.m4 (cshift1): Ditto.
+ * m4/eoshift1.m4 (eoshift1): Ditto.
+ * m4/eoshift3.m4 (eoshift3): Ditto.
+ * m4/iforeach.m4 (name`'rtype_qual`_'atype_code): Ditto.
+ * m4/ifunction.m4 (name`'rtype_qual`_'atype_code): Ditto.
+ * m4/ifunction_logical.m4 (name`'rtype_qual`_'atype_code): Ditto.
+ * m4/in_pack.m4 (internal_pack_'rtype_ccode`): Ditto.
+ * m4/in_unpack.m4 (internal_unpack_'rtype_ccode`): Ditto.
+ * m4/matmul.m4 (matmul_'rtype_code`): Ditto.
+ * m4/matmull.m4 (matmul_'rtype_code`): Ditto.
+ * m4/pack.m4 (pack_'rtype_code`): Ditto.
+ * m4/reshape.m4 (reshape_'rtype_ccode`): Ditto.
+ * m4/shape.m4 (shape_'rtype_kind`): Ditto.
+ * m4/spread.m4 (spread_'rtype_code`): Ditto.
+ * m4/transpose.m4 (transpose_'rtype_code`): Ditto.
+ * m4/unpack.m4 (unpack0_'rtype_code`, unpack1_'rtype_code`): Ditto.
+ * runtime/bounds.c (count_0): Ditto.
+ * runtime/in_pack_generic.c (internal_pack): Ditto.
+ * runtime/in_unpack_generic.c (internal_unpack): Ditto.
+ * generated/cshift0_r4.c: Regenerated.
+ * generated/unpack_r8.c: Regenerated.
+ * generated/cshift0_c10.c: Regenerated.
+ * generated/in_unpack_i1.c: Regenerated.
+ * generated/eoshift1_16.c: Regenerated.
+ * generated/iany_i16.c: Regenerated.
+ * generated/reshape_i4.c: Regenerated.
+ * generated/parity_l16.c: Regenerated.
+ * generated/in_unpack_r16.c: Regenerated.
+ * generated/iparity_i1.c: Regenerated.
+ * generated/minloc0_16_r10.c: Regenerated.
+ * generated/minloc1_16_i8.c: Regenerated.
+ * generated/bessel_r8.c: Regenerated.
+ * generated/maxloc0_4_i8.c: Regenerated.
+ * generated/maxloc1_8_i1.c: Regenerated.
+ * generated/sum_c10.c: Regenerated.
+ * generated/maxloc0_8_r10.c: Regenerated.
+ * generated/unpack_r16.c: Regenerated.
+ * generated/maxloc1_16_i1.c: Regenerated.
+ * generated/minloc1_4_i1.c: Regenerated.
+ * generated/unpack_i4.c: Regenerated.
+ * generated/in_pack_i1.c: Regenerated.
+ * generated/cshift0_i1.c: Regenerated.
+ * generated/minloc0_16_i4.c: Regenerated.
+ * generated/minloc1_8_r8.c: Regenerated.
+ * generated/maxval_r8.c: Regenerated.
+ * generated/unpack_i2.c: Regenerated.
+ * generated/matmul_r16.c: Regenerated.
+ * generated/maxloc0_16_r8.c: Regenerated.
+ * generated/maxloc1_8_i16.c: Regenerated.
+ * generated/maxloc0_4_r4.c: Regenerated.
+ * generated/pack_c10.c: Regenerated.
+ * generated/in_unpack_c8.c: Regenerated.
+ * generated/maxloc1_8_i8.c: Regenerated.
+ * generated/in_pack_c16.c: Regenerated.
+ * generated/parity_l1.c: Regenerated.
+ * generated/in_pack_i2.c: Regenerated.
+ * generated/maxloc0_4_r8.c: Regenerated.
+ * generated/pack_r4.c: Regenerated.
+ * generated/matmul_r8.c: Regenerated.
+ * generated/pack_i1.c: Regenerated.
+ * generated/minloc0_16_r16.c: Regenerated.
+ * generated/cshift0_c8.c: Regenerated.
+ * generated/minloc1_4_i16.c: Regenerated.
+ * generated/minloc0_4_r4.c: Regenerated.
+ * generated/product_i2.c: Regenerated.
+ * generated/maxval_r10.c: Regenerated.
+ * generated/minloc0_16_r8.c: Regenerated.
+ * generated/in_pack_i8.c: Regenerated.
+ * generated/all_l8.c: Regenerated.
+ * generated/minloc0_8_i16.c: Regenerated.
+ * generated/minloc1_8_i2.c: Regenerated.
+ * generated/matmul_l8.c: Regenerated.
+ * generated/spread_r10.c: Regenerated.
+ * generated/product_c4.c: Regenerated.
+ * generated/reshape_r16.c: Regenerated.
+ * generated/cshift0_i16.c: Regenerated.
+ * generated/minloc1_8_r10.c: Regenerated.
+ * generated/iparity_i8.c: Regenerated.
+ * generated/minloc0_16_i8.c: Regenerated.
+ * generated/minloc1_8_i1.c: Regenerated.
+ * generated/maxloc0_16_r10.c: Regenerated.
+ * generated/maxloc1_8_i4.c: Regenerated.
+ * generated/maxloc0_16_i8.c: Regenerated.
+ * generated/maxloc1_16_i16.c: Regenerated.
+ * generated/reshape_i8.c: Regenerated.
+ * generated/all_l16.c: Regenerated.
+ * generated/cshift1_8.c: Regenerated.
+ * generated/matmul_c10.c: Regenerated.
+ * generated/pack_r16.c: Regenerated.
+ * generated/transpose_r10.c: Regenerated.
+ * generated/maxloc1_16_i2.c: Regenerated.
+ * generated/minloc1_4_r4.c: Regenerated.
+ * generated/reshape_r8.c: Regenerated.
+ * generated/product_r10.c: Regenerated.
+ * generated/spread_c10.c: Regenerated.
+ * generated/reshape_r4.c: Regenerated.
+ * generated/in_unpack_i4.c: Regenerated.
+ * generated/minval_r4.c: Regenerated.
+ * generated/minloc1_16_r16.c: Regenerated.
+ * generated/norm2_r8.c: Regenerated.
+ * generated/iany_i2.c: Regenerated.
+ * generated/eoshift3_8.c: Regenerated.
+ * generated/maxloc1_16_r8.c: Regenerated.
+ * generated/maxloc0_16_r16.c: Regenerated.
+ * generated/cshift0_i8.c: Regenerated.
+ * generated/all_l1.c: Regenerated.
+ * generated/minloc1_16_r10.c: Regenerated.
+ * generated/spread_i16.c: Regenerated.
+ * generated/minloc1_8_r16.c: Regenerated.
+ * generated/spread_r16.c: Regenerated.
+ * generated/matmul_c8.c: Regenerated.
+ * generated/pack_r10.c: Regenerated.
+ * generated/reshape_r10.c: Regenerated.
+ * generated/sum_r10.c: Regenerated.
+ * generated/count_8_l.c: Regenerated.
+ * generated/minloc1_16_i16.c: Regenerated.
+ * generated/maxloc0_16_i2.c: Regenerated.
+ * generated/count_1_l.c: Regenerated.
+ * generated/unpack_c16.c: Regenerated.
+ * generated/any_l8.c: Regenerated.
+ * generated/minloc1_16_i1.c: Regenerated.
+ * generated/sum_r4.c: Regenerated.
+ * generated/in_unpack_r8.c: Regenerated.
+ * generated/product_r8.c: Regenerated.
+ * generated/in_unpack_r4.c: Regenerated.
+ * generated/unpack_i1.c: Regenerated.
+ * generated/cshift0_r8.c: Regenerated.
+ * generated/spread_i2.c: Regenerated.
+ * generated/minloc1_4_r10.c: Regenerated.
+ * generated/minloc1_16_i2.c: Regenerated.
+ * generated/minloc0_16_i2.c: Regenerated.
+ * generated/eoshift3_16.c: Regenerated.
+ * generated/maxloc0_8_i4.c: Regenerated.
+ * generated/maxloc1_16_r10.c: Regenerated.
+ * generated/maxloc1_4_i16.c: Regenerated.
+ * generated/maxloc1_4_r8.c: Regenerated.
+ * generated/parity_l2.c: Regenerated.
+ * generated/maxloc0_16_i16.c: Regenerated.
+ * generated/product_r4.c: Regenerated.
+ * generated/in_unpack_r10.c: Regenerated.
+ * generated/maxloc1_8_i2.c: Regenerated.
+ * generated/iparity_i2.c: Regenerated.
+ * generated/maxloc1_8_r4.c: Regenerated.
+ * generated/maxloc1_8_r8.c: Regenerated.
+ * generated/iall_i4.c: Regenerated.
+ * generated/maxloc0_4_i16.c: Regenerated.
+ * generated/cshift0_i4.c: Regenerated.
+ * generated/in_unpack_c10.c: Regenerated.
+ * generated/unpack_c8.c: Regenerated.
+ * generated/transpose_c8.c: Regenerated.
+ * generated/in_unpack_c16.c: Regenerated.
+ * generated/product_c16.c: Regenerated.
+ * generated/minval_r8.c: Regenerated.
+ * generated/minloc0_4_i1.c: Regenerated.
+ * generated/minloc0_8_r16.c: Regenerated.
+ * generated/in_unpack_i16.c: Regenerated.
+ * generated/reshape_c16.c: Regenerated.
+ * generated/pack_i4.c: Regenerated.
+ * generated/minval_r10.c: Regenerated.
+ * generated/maxloc0_4_r10.c: Regenerated.
+ * generated/unpack_i8.c: Regenerated.
+ * generated/minloc1_16_r8.c: Regenerated.
+ * generated/pack_c16.c: Regenerated.
+ * generated/maxval_r4.c: Regenerated.
+ * generated/spread_r8.c: Regenerated.
+ * generated/minloc0_16_r4.c: Regenerated.
+ * generated/maxval_i4.c: Regenerated.
+ * generated/matmul_r4.c: Regenerated.
+ * generated/product_c8.c: Regenerated.
+ * generated/maxloc1_4_i4.c: Regenerated.
+ * generated/any_l4.c: Regenerated.
+ * generated/cshift0_r16.c: Regenerated.
+ * generated/maxloc1_16_r4.c: Regenerated.
+ * generated/in_pack_r10.c: Regenerated.
+ * generated/iall_i1.c: Regenerated.
+ * generated/product_i1.c: Regenerated.
+ * generated/maxloc0_4_i1.c: Regenerated.
+ * generated/maxloc0_8_r16.c: Regenerated.
+ * generated/minloc1_8_i16.c: Regenerated.
+ * generated/reshape_c10.c: Regenerated.
+ * generated/matmul_l4.c: Regenerated.
+ * generated/cshift0_c16.c: Regenerated.
+ * generated/spread_r4.c: Regenerated.
+ * generated/sum_r16.c: Regenerated.
+ * generated/in_unpack_c4.c: Regenerated.
+ * generated/maxval_i8.c: Regenerated.
+ * generated/maxloc0_8_r8.c: Regenerated.
+ * generated/unpack_i16.c: Regenerated.
+ * generated/norm2_r4.c: Regenerated.
+ * generated/maxloc1_4_r16.c: Regenerated.
+ * generated/in_pack_r4.c: Regenerated.
+ * generated/sum_c8.c: Regenerated.
+ * generated/parity_l8.c: Regenerated.
+ * generated/minval_i2.c: Regenerated.
+ * generated/transpose_c10.c: Regenerated.
+ * generated/cshift0_r10.c: Regenerated.
+ * generated/cshift0_i2.c: Regenerated.
+ * generated/spread_c4.c: Regenerated.
+ * generated/maxval_r16.c: Regenerated.
+ * generated/unpack_c10.c: Regenerated.
+ * generated/bessel_r4.c: Regenerated.
+ * generated/minloc0_8_i1.c: Regenerated.
+ * generated/product_c10.c: Regenerated.
+ * generated/minloc1_4_i4.c: Regenerated.
+ * generated/minloc1_4_i2.c: Regenerated.
+ * generated/transpose_c4.c: Regenerated.
+ * generated/in_pack_c8.c: Regenerated.
+ * generated/minval_i8.c: Regenerated.
+ * generated/maxloc1_4_i2.c: Regenerated.
+ * generated/maxloc1_4_i1.c: Regenerated.
+ * generated/iall_i8.c: Regenerated.
+ * generated/iany_i8.c: Regenerated.
+ * generated/sum_c16.c: Regenerated.
+ * generated/spread_i8.c: Regenerated.
+ * generated/sum_i8.c: Regenerated.
+ * generated/pack_i2.c: Regenerated.
+ * generated/unpack_r10.c: Regenerated.
+ * generated/minloc0_4_i4.c: Regenerated.
+ * generated/iany_i4.c: Regenerated.
+ * generated/maxloc0_4_i4.c: Regenerated.
+ * generated/in_pack_r8.c: Regenerated.
+ * generated/spread_i1.c: Regenerated.
+ * generated/maxval_i16.c: Regenerated.
+ * generated/pack_c8.c: Regenerated.
+ * generated/iparity_i16.c: Regenerated.
+ * generated/matmul_c16.c: Regenerated.
+ * generated/eoshift1_8.c: Regenerated.
+ * generated/any_l16.c: Regenerated.
+ * generated/maxloc1_4_i8.c: Regenerated.
+ * generated/minloc0_8_r4.c: Regenerated.
+ * generated/transpose_c16.c: Regenerated.
+ * generated/reshape_c4.c: Regenerated.
+ * generated/minloc0_8_r8.c: Regenerated.
+ * generated/count_16_l.c: Regenerated.
+ * generated/minloc0_16_i1.c: Regenerated.
+ * generated/minloc1_16_r4.c: Regenerated.
+ * generated/maxloc0_8_i1.c: Regenerated.
+ * generated/matmul_i1.c: Regenerated.
+ * generated/sum_i2.c: Regenerated.
+ * generated/cshift1_4.c: Regenerated.
+ * generated/minloc0_4_i2.c: Regenerated.
+ * generated/bessel_r10.c: Regenerated.
+ * generated/matmul_c4.c: Regenerated.
+ * generated/parity_l4.c: Regenerated.
+ * generated/in_unpack_i2.c: Regenerated.
+ * generated/product_i16.c: Regenerated.
+ * generated/maxloc0_16_i4.c: Regenerated.
+ * generated/minloc0_4_r10.c: Regenerated.
+ * generated/transpose_i16.c: Regenerated.
+ * generated/matmul_l16.c: Regenerated.
+ * generated/any_l1.c: Regenerated.
+ * generated/minval_r16.c: Regenerated.
+ * generated/shape_i16.c: Regenerated.
+ * generated/in_pack_c4.c: Regenerated.
+ * generated/minloc1_8_r4.c: Regenerated.
+ * generated/iany_i1.c: Regenerated.
+ * generated/matmul_i16.c: Regenerated.
+ * generated/maxloc0_16_r4.c: Regenerated.
+ * generated/spread_c8.c: Regenerated.
+ * generated/product_i8.c: Regenerated.
+ * generated/minloc1_8_i4.c: Regenerated.
+ * generated/product_i4.c: Regenerated.
+ * generated/minval_i16.c: Regenerated.
+ * generated/pack_r8.c: Regenerated.
+ * generated/matmul_r10.c: Regenerated.
+ * generated/shape_i8.c: Regenerated.
+ * generated/eoshift1_4.c: Regenerated.
+ * generated/minloc1_16_i4.c: Regenerated.
+ * generated/transpose_r16.c: Regenerated.
+ * generated/spread_c16.c: Regenerated.
+ * generated/maxloc0_8_i16.c: Regenerated.
+ * generated/minval_i1.c: Regenerated.
+ * generated/sum_i4.c: Regenerated.
+ * generated/in_pack_r16.c: Regenerated.
+ * generated/iall_i16.c: Regenerated.
+ * generated/minloc0_8_r10.c: Regenerated.
+ * generated/maxloc0_8_i8.c: Regenerated.
+ * generated/transpose_i4.c: Regenerated.
+ * generated/maxloc0_4_i2.c: Regenerated.
+ * generated/iall_i2.c: Regenerated.
+ * generated/maxloc0_8_r4.c: Regenerated.
+ * generated/minloc0_4_r16.c: Regenerated.
+ * generated/minloc1_4_r8.c: Regenerated.
+ * generated/minloc0_4_i8.c: Regenerated.
+ * generated/minval_i4.c: Regenerated.
+ * generated/minloc1_8_i8.c: Regenerated.
+ * generated/in_pack_i16.c: Regenerated.
+ * generated/spread_i4.c: Regenerated.
+ * generated/cshift0_c4.c: Regenerated.
+ * generated/minloc0_4_i16.c: Regenerated.
+ * generated/sum_r8.c: Regenerated.
+ * generated/minloc0_16_i16.c: Regenerated.
+ * generated/sum_i1.c: Regenerated.
+ * generated/all_l2.c: Regenerated.
+ * generated/sum_c4.c: Regenerated.
+ * generated/shape_i4.c: Regenerated.
+ * generated/maxval_i1.c: Regenerated.
+ * generated/norm2_r10.c: Regenerated.
+ * generated/unpack_c4.c: Regenerated.
+ * generated/maxloc0_16_i1.c: Regenerated.
+ * generated/all_l4.c: Regenerated.
+ * generated/maxloc1_16_i8.c: Regenerated.
+ * generated/sum_i16.c: Regenerated.
+ * generated/maxloc1_8_r16.c: Regenerated.
+ * generated/minloc1_4_r16.c: Regenerated.
+ * generated/maxloc1_16_r16.c: Regenerated.
+ * generated/transpose_i8.c: Regenerated.
+ * generated/minloc0_8_i2.c: Regenerated.
+ * generated/product_r16.c: Regenerated.
+ * generated/in_pack_c10.c: Regenerated.
+ * generated/maxloc0_4_r16.c: Regenerated.
+ * generated/pack_c4.c: Regenerated.
+ * generated/bessel_r16.c: Regenerated.
+ * generated/norm2_r16.c: Regenerated.
+ * generated/in_unpack_i8.c: Regenerated.
+ * generated/maxloc1_16_i4.c: Regenerated.
+ * generated/minloc1_4_i8.c: Regenerated.
+ * generated/eoshift3_4.c: Regenerated.
+ * generated/maxloc1_8_r10.c: Regenerated.
+ * generated/matmul_i8.c: Regenerated.
+ * generated/matmul_i4.c: Regenerated.
+ * generated/reshape_i16.c: Regenerated.
+ * generated/matmul_i2.c: Regenerated.
+ * generated/transpose_r8.c: Regenerated.
+ * generated/transpose_r4.c: Regenerated.
+ * generated/cshift1_16.c: Regenerated.
+ * generated/maxloc1_4_r10.c: Regenerated.
+ * generated/iparity_i4.c: Regenerated.
+ * generated/in_pack_i4.c: Regenerated.
+ * generated/maxloc0_8_i2.c: Regenerated.
+ * generated/unpack_r4.c: Regenerated.
+ * generated/count_4_l.c: Regenerated.
+ * generated/maxloc1_4_r4.c: Regenerated.
+ * generated/minloc0_8_i8.c: Regenerated.
+ * generated/any_l2.c: Regenerated.
+ * generated/minloc0_8_i4.c: Regenerated.
+ * generated/pack_i8.c: Regenerated.
+ * generated/count_2_l.c: Regenerated.
+ * generated/reshape_c8.c: Regenerated.
+ * generated/maxval_i2.c: Regenerated.
+ * generated/minloc0_4_r8.c: Regenerated.
+
2012-01-20 Tobias Burnus <burnus@net-b.de>
PR libgfortran/51899
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
+ base = array->base_addr;
if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
else
internal_error (NULL, "Funny sized logical array in ALL intrinsic");
- dest = retarray->data;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
+ base = array->base_addr;
if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
else
internal_error (NULL, "Funny sized logical array in ALL intrinsic");
- dest = retarray->data;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
+ base = array->base_addr;
if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
else
internal_error (NULL, "Funny sized logical array in ALL intrinsic");
- dest = retarray->data;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
+ base = array->base_addr;
if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
else
internal_error (NULL, "Funny sized logical array in ALL intrinsic");
- dest = retarray->data;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
+ base = array->base_addr;
if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
else
internal_error (NULL, "Funny sized logical array in ALL intrinsic");
- dest = retarray->data;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
+ base = array->base_addr;
if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
else
internal_error (NULL, "Funny sized logical array in ANY intrinsic");
- dest = retarray->data;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
+ base = array->base_addr;
if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
else
internal_error (NULL, "Funny sized logical array in ANY intrinsic");
- dest = retarray->data;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
+ base = array->base_addr;
if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
else
internal_error (NULL, "Funny sized logical array in ANY intrinsic");
- dest = retarray->data;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
+ base = array->base_addr;
if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
else
internal_error (NULL, "Funny sized logical array in ANY intrinsic");
- dest = retarray->data;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
+ base = array->base_addr;
if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
else
internal_error (NULL, "Funny sized logical array in ANY intrinsic");
- dest = retarray->data;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
/* Implementation of the BESSEL_JN and BESSEL_YN transformational
function using a recurrence algorithm.
- Copyright 2010 Free Software Foundation, Inc.
+ Copyright 2010, 2012 Free Software Foundation, Inc.
Contributed by Tobias Burnus <burnus@net-b.de>
This file is part of the GNU Fortran runtime library (libgfortran).
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t size = n2 < n1 ? 0 : n2-n1+1;
GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
- ret->data = internal_malloc_size (sizeof (GFC_REAL_10) * size);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_10) * size);
ret->offset = 0;
}
if (unlikely (x == 0))
{
- ret->data[0] = 1;
+ ret->base_addr[0] = 1;
for (i = 1; i <= n2-n1; i++)
- ret->data[i*stride] = 0;
+ ret->base_addr[i*stride] = 0;
return;
}
- ret->data = ret->data;
last1 = MATHFUNC(jn) (n2, x);
- ret->data[(n2-n1)*stride] = last1;
+ ret->base_addr[(n2-n1)*stride] = last1;
if (n1 == n2)
return;
last2 = MATHFUNC(jn) (n2 - 1, x);
- ret->data[(n2-n1-1)*stride] = last2;
+ ret->base_addr[(n2-n1-1)*stride] = last2;
if (n1 + 1 == n2)
return;
for (i = n2-n1-2; i >= 0; i--)
{
- ret->data[i*stride] = x2rev * (i+1+n1) * last2 - last1;
+ ret->base_addr[i*stride] = x2rev * (i+1+n1) * last2 - last1;
last1 = last2;
- last2 = ret->data[i*stride];
+ last2 = ret->base_addr[i*stride];
}
}
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t size = n2 < n1 ? 0 : n2-n1+1;
GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
- ret->data = internal_malloc_size (sizeof (GFC_REAL_10) * size);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_10) * size);
ret->offset = 0;
}
{
for (i = 0; i <= n2-n1; i++)
#if defined(GFC_REAL_10_INFINITY)
- ret->data[i*stride] = -GFC_REAL_10_INFINITY;
+ ret->base_addr[i*stride] = -GFC_REAL_10_INFINITY;
#else
- ret->data[i*stride] = -GFC_REAL_10_HUGE;
+ ret->base_addr[i*stride] = -GFC_REAL_10_HUGE;
#endif
return;
}
- ret->data = ret->data;
+ ret->base_addr = ret->base_addr;
last1 = MATHFUNC(yn) (n1, x);
- ret->data[0] = last1;
+ ret->base_addr[0] = last1;
if (n1 == n2)
return;
last2 = MATHFUNC(yn) (n1 + 1, x);
- ret->data[1*stride] = last2;
+ ret->base_addr[1*stride] = last2;
if (n1 + 1 == n2)
return;
#if defined(GFC_REAL_10_INFINITY)
if (unlikely (last2 == -GFC_REAL_10_INFINITY))
{
- ret->data[i*stride] = -GFC_REAL_10_INFINITY;
+ ret->base_addr[i*stride] = -GFC_REAL_10_INFINITY;
}
else
#endif
{
- ret->data[i*stride] = x2rev * (i-1+n1) * last2 - last1;
+ ret->base_addr[i*stride] = x2rev * (i-1+n1) * last2 - last1;
last1 = last2;
- last2 = ret->data[i*stride];
+ last2 = ret->base_addr[i*stride];
}
}
}
/* Implementation of the BESSEL_JN and BESSEL_YN transformational
function using a recurrence algorithm.
- Copyright 2010 Free Software Foundation, Inc.
+ Copyright 2010, 2012 Free Software Foundation, Inc.
Contributed by Tobias Burnus <burnus@net-b.de>
This file is part of the GNU Fortran runtime library (libgfortran).
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t size = n2 < n1 ? 0 : n2-n1+1;
GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
- ret->data = internal_malloc_size (sizeof (GFC_REAL_16) * size);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_16) * size);
ret->offset = 0;
}
if (unlikely (x == 0))
{
- ret->data[0] = 1;
+ ret->base_addr[0] = 1;
for (i = 1; i <= n2-n1; i++)
- ret->data[i*stride] = 0;
+ ret->base_addr[i*stride] = 0;
return;
}
- ret->data = ret->data;
last1 = MATHFUNC(jn) (n2, x);
- ret->data[(n2-n1)*stride] = last1;
+ ret->base_addr[(n2-n1)*stride] = last1;
if (n1 == n2)
return;
last2 = MATHFUNC(jn) (n2 - 1, x);
- ret->data[(n2-n1-1)*stride] = last2;
+ ret->base_addr[(n2-n1-1)*stride] = last2;
if (n1 + 1 == n2)
return;
for (i = n2-n1-2; i >= 0; i--)
{
- ret->data[i*stride] = x2rev * (i+1+n1) * last2 - last1;
+ ret->base_addr[i*stride] = x2rev * (i+1+n1) * last2 - last1;
last1 = last2;
- last2 = ret->data[i*stride];
+ last2 = ret->base_addr[i*stride];
}
}
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t size = n2 < n1 ? 0 : n2-n1+1;
GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
- ret->data = internal_malloc_size (sizeof (GFC_REAL_16) * size);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_16) * size);
ret->offset = 0;
}
{
for (i = 0; i <= n2-n1; i++)
#if defined(GFC_REAL_16_INFINITY)
- ret->data[i*stride] = -GFC_REAL_16_INFINITY;
+ ret->base_addr[i*stride] = -GFC_REAL_16_INFINITY;
#else
- ret->data[i*stride] = -GFC_REAL_16_HUGE;
+ ret->base_addr[i*stride] = -GFC_REAL_16_HUGE;
#endif
return;
}
- ret->data = ret->data;
+ ret->base_addr = ret->base_addr;
last1 = MATHFUNC(yn) (n1, x);
- ret->data[0] = last1;
+ ret->base_addr[0] = last1;
if (n1 == n2)
return;
last2 = MATHFUNC(yn) (n1 + 1, x);
- ret->data[1*stride] = last2;
+ ret->base_addr[1*stride] = last2;
if (n1 + 1 == n2)
return;
#if defined(GFC_REAL_16_INFINITY)
if (unlikely (last2 == -GFC_REAL_16_INFINITY))
{
- ret->data[i*stride] = -GFC_REAL_16_INFINITY;
+ ret->base_addr[i*stride] = -GFC_REAL_16_INFINITY;
}
else
#endif
{
- ret->data[i*stride] = x2rev * (i-1+n1) * last2 - last1;
+ ret->base_addr[i*stride] = x2rev * (i-1+n1) * last2 - last1;
last1 = last2;
- last2 = ret->data[i*stride];
+ last2 = ret->base_addr[i*stride];
}
}
}
/* Implementation of the BESSEL_JN and BESSEL_YN transformational
function using a recurrence algorithm.
- Copyright 2010 Free Software Foundation, Inc.
+ Copyright 2010, 2012 Free Software Foundation, Inc.
Contributed by Tobias Burnus <burnus@net-b.de>
This file is part of the GNU Fortran runtime library (libgfortran).
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t size = n2 < n1 ? 0 : n2-n1+1;
GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
- ret->data = internal_malloc_size (sizeof (GFC_REAL_4) * size);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_4) * size);
ret->offset = 0;
}
if (unlikely (x == 0))
{
- ret->data[0] = 1;
+ ret->base_addr[0] = 1;
for (i = 1; i <= n2-n1; i++)
- ret->data[i*stride] = 0;
+ ret->base_addr[i*stride] = 0;
return;
}
- ret->data = ret->data;
last1 = MATHFUNC(jn) (n2, x);
- ret->data[(n2-n1)*stride] = last1;
+ ret->base_addr[(n2-n1)*stride] = last1;
if (n1 == n2)
return;
last2 = MATHFUNC(jn) (n2 - 1, x);
- ret->data[(n2-n1-1)*stride] = last2;
+ ret->base_addr[(n2-n1-1)*stride] = last2;
if (n1 + 1 == n2)
return;
for (i = n2-n1-2; i >= 0; i--)
{
- ret->data[i*stride] = x2rev * (i+1+n1) * last2 - last1;
+ ret->base_addr[i*stride] = x2rev * (i+1+n1) * last2 - last1;
last1 = last2;
- last2 = ret->data[i*stride];
+ last2 = ret->base_addr[i*stride];
}
}
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t size = n2 < n1 ? 0 : n2-n1+1;
GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
- ret->data = internal_malloc_size (sizeof (GFC_REAL_4) * size);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_4) * size);
ret->offset = 0;
}
{
for (i = 0; i <= n2-n1; i++)
#if defined(GFC_REAL_4_INFINITY)
- ret->data[i*stride] = -GFC_REAL_4_INFINITY;
+ ret->base_addr[i*stride] = -GFC_REAL_4_INFINITY;
#else
- ret->data[i*stride] = -GFC_REAL_4_HUGE;
+ ret->base_addr[i*stride] = -GFC_REAL_4_HUGE;
#endif
return;
}
- ret->data = ret->data;
+ ret->base_addr = ret->base_addr;
last1 = MATHFUNC(yn) (n1, x);
- ret->data[0] = last1;
+ ret->base_addr[0] = last1;
if (n1 == n2)
return;
last2 = MATHFUNC(yn) (n1 + 1, x);
- ret->data[1*stride] = last2;
+ ret->base_addr[1*stride] = last2;
if (n1 + 1 == n2)
return;
#if defined(GFC_REAL_4_INFINITY)
if (unlikely (last2 == -GFC_REAL_4_INFINITY))
{
- ret->data[i*stride] = -GFC_REAL_4_INFINITY;
+ ret->base_addr[i*stride] = -GFC_REAL_4_INFINITY;
}
else
#endif
{
- ret->data[i*stride] = x2rev * (i-1+n1) * last2 - last1;
+ ret->base_addr[i*stride] = x2rev * (i-1+n1) * last2 - last1;
last1 = last2;
- last2 = ret->data[i*stride];
+ last2 = ret->base_addr[i*stride];
}
}
}
/* Implementation of the BESSEL_JN and BESSEL_YN transformational
function using a recurrence algorithm.
- Copyright 2010 Free Software Foundation, Inc.
+ Copyright 2010, 2012 Free Software Foundation, Inc.
Contributed by Tobias Burnus <burnus@net-b.de>
This file is part of the GNU Fortran runtime library (libgfortran).
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t size = n2 < n1 ? 0 : n2-n1+1;
GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
- ret->data = internal_malloc_size (sizeof (GFC_REAL_8) * size);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_8) * size);
ret->offset = 0;
}
if (unlikely (x == 0))
{
- ret->data[0] = 1;
+ ret->base_addr[0] = 1;
for (i = 1; i <= n2-n1; i++)
- ret->data[i*stride] = 0;
+ ret->base_addr[i*stride] = 0;
return;
}
- ret->data = ret->data;
last1 = MATHFUNC(jn) (n2, x);
- ret->data[(n2-n1)*stride] = last1;
+ ret->base_addr[(n2-n1)*stride] = last1;
if (n1 == n2)
return;
last2 = MATHFUNC(jn) (n2 - 1, x);
- ret->data[(n2-n1-1)*stride] = last2;
+ ret->base_addr[(n2-n1-1)*stride] = last2;
if (n1 + 1 == n2)
return;
for (i = n2-n1-2; i >= 0; i--)
{
- ret->data[i*stride] = x2rev * (i+1+n1) * last2 - last1;
+ ret->base_addr[i*stride] = x2rev * (i+1+n1) * last2 - last1;
last1 = last2;
- last2 = ret->data[i*stride];
+ last2 = ret->base_addr[i*stride];
}
}
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t size = n2 < n1 ? 0 : n2-n1+1;
GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
- ret->data = internal_malloc_size (sizeof (GFC_REAL_8) * size);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_8) * size);
ret->offset = 0;
}
{
for (i = 0; i <= n2-n1; i++)
#if defined(GFC_REAL_8_INFINITY)
- ret->data[i*stride] = -GFC_REAL_8_INFINITY;
+ ret->base_addr[i*stride] = -GFC_REAL_8_INFINITY;
#else
- ret->data[i*stride] = -GFC_REAL_8_HUGE;
+ ret->base_addr[i*stride] = -GFC_REAL_8_HUGE;
#endif
return;
}
- ret->data = ret->data;
+ ret->base_addr = ret->base_addr;
last1 = MATHFUNC(yn) (n1, x);
- ret->data[0] = last1;
+ ret->base_addr[0] = last1;
if (n1 == n2)
return;
last2 = MATHFUNC(yn) (n1 + 1, x);
- ret->data[1*stride] = last2;
+ ret->base_addr[1*stride] = last2;
if (n1 + 1 == n2)
return;
#if defined(GFC_REAL_8_INFINITY)
if (unlikely (last2 == -GFC_REAL_8_INFINITY))
{
- ret->data[i*stride] = -GFC_REAL_8_INFINITY;
+ ret->base_addr[i*stride] = -GFC_REAL_8_INFINITY;
}
else
#endif
{
- ret->data[i*stride] = x2rev * (i-1+n1) * last2 - last1;
+ ret->base_addr[i*stride] = x2rev * (i-1+n1) * last2 - last1;
last1 = last2;
- last2 = ret->data[i*stride];
+ last2 = ret->base_addr[i*stride];
}
}
}
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
+ base = array->base_addr;
if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
else
internal_error (NULL, "Funny sized logical array in COUNT intrinsic");
- dest = retarray->data;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
+ base = array->base_addr;
if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
else
internal_error (NULL, "Funny sized logical array in COUNT intrinsic");
- dest = retarray->data;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
+ base = array->base_addr;
if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
else
internal_error (NULL, "Funny sized logical array in COUNT intrinsic");
- dest = retarray->data;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
+ base = array->base_addr;
if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
else
internal_error (NULL, "Funny sized logical array in COUNT intrinsic");
- dest = retarray->data;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
+ base = array->base_addr;
if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
else
internal_error (NULL, "Funny sized logical array in COUNT intrinsic");
- dest = retarray->data;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
/* Helper function for cshift functions.
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
rstride0 = rstride[0];
sstride0 = sstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
if (shift < 0)
/* Helper function for cshift functions.
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
rstride0 = rstride[0];
sstride0 = sstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
if (shift < 0)
/* Helper function for cshift functions.
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
rstride0 = rstride[0];
sstride0 = sstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
if (shift < 0)
/* Helper function for cshift functions.
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
rstride0 = rstride[0];
sstride0 = sstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
if (shift < 0)
/* Helper function for cshift functions.
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
rstride0 = rstride[0];
sstride0 = sstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
if (shift < 0)
/* Helper function for cshift functions.
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
rstride0 = rstride[0];
sstride0 = sstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
if (shift < 0)
/* Helper function for cshift functions.
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
rstride0 = rstride[0];
sstride0 = sstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
if (shift < 0)
/* Helper function for cshift functions.
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
rstride0 = rstride[0];
sstride0 = sstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
if (shift < 0)
/* Helper function for cshift functions.
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
rstride0 = rstride[0];
sstride0 = sstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
if (shift < 0)
/* Helper function for cshift functions.
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
rstride0 = rstride[0];
sstride0 = sstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
if (shift < 0)
/* Helper function for cshift functions.
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
rstride0 = rstride[0];
sstride0 = sstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
if (shift < 0)
/* Helper function for cshift functions.
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
rstride0 = rstride[0];
sstride0 = sstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
if (shift < 0)
/* Helper function for cshift functions.
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
rstride0 = rstride[0];
sstride0 = sstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
if (shift < 0)
/* Implementation of the CSHIFT intrinsic
- Copyright 2003, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Feng Wang <wf_cs@yahoo.com>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
arraysize = size0 ((array_t *)array);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
int i;
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
ret->offset = 0;
ret->dtype = array->dtype;
for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
rstride0 = rstride[0];
sstride0 = sstride[0];
hstride0 = hstride[0];
- rptr = ret->data;
- sptr = array->data;
- hptr = h->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
+ hptr = h->base_addr;
while (rptr)
{
/* Implementation of the CSHIFT intrinsic
- Copyright 2003, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Feng Wang <wf_cs@yahoo.com>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
arraysize = size0 ((array_t *)array);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
int i;
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
ret->offset = 0;
ret->dtype = array->dtype;
for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
rstride0 = rstride[0];
sstride0 = sstride[0];
hstride0 = hstride[0];
- rptr = ret->data;
- sptr = array->data;
- hptr = h->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
+ hptr = h->base_addr;
while (rptr)
{
/* Implementation of the CSHIFT intrinsic
- Copyright 2003, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Feng Wang <wf_cs@yahoo.com>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
arraysize = size0 ((array_t *)array);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
int i;
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
ret->offset = 0;
ret->dtype = array->dtype;
for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
rstride0 = rstride[0];
sstride0 = sstride[0];
hstride0 = hstride[0];
- rptr = ret->data;
- sptr = array->data;
- hptr = h->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
+ hptr = h->base_addr;
while (rptr)
{
/* Implementation of the EOSHIFT intrinsic
- Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
count[0] = 0;
arraysize = size0 ((array_t *) array);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
int i;
}
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
}
else if (unlikely (compile_options.bounds_check))
rstride0 = rstride[0];
sstride0 = sstride[0];
hstride0 = hstride[0];
- rptr = ret->data;
- sptr = array->data;
- hptr = h->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
+ hptr = h->base_addr;
while (rptr)
{
/* Implementation of the EOSHIFT intrinsic
- Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
count[0] = 0;
arraysize = size0 ((array_t *) array);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
int i;
}
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
}
else if (unlikely (compile_options.bounds_check))
rstride0 = rstride[0];
sstride0 = sstride[0];
hstride0 = hstride[0];
- rptr = ret->data;
- sptr = array->data;
- hptr = h->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
+ hptr = h->base_addr;
while (rptr)
{
/* Implementation of the EOSHIFT intrinsic
- Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
count[0] = 0;
arraysize = size0 ((array_t *) array);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
int i;
}
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
}
else if (unlikely (compile_options.bounds_check))
rstride0 = rstride[0];
sstride0 = sstride[0];
hstride0 = hstride[0];
- rptr = ret->data;
- sptr = array->data;
- hptr = h->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
+ hptr = h->base_addr;
while (rptr)
{
/* Implementation of the EOSHIFT intrinsic
- Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
else
which = 0;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
int i;
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
ret->offset = 0;
ret->dtype = array->dtype;
for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
}
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
}
else if (unlikely (compile_options.bounds_check))
sstride0 = sstride[0];
hstride0 = hstride[0];
bstride0 = bstride[0];
- rptr = ret->data;
- sptr = array->data;
- hptr = h->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
+ hptr = h->base_addr;
if (bound)
- bptr = bound->data;
+ bptr = bound->base_addr;
else
bptr = NULL;
/* Implementation of the EOSHIFT intrinsic
- Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
else
which = 0;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
int i;
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
ret->offset = 0;
ret->dtype = array->dtype;
for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
}
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
}
else if (unlikely (compile_options.bounds_check))
sstride0 = sstride[0];
hstride0 = hstride[0];
bstride0 = bstride[0];
- rptr = ret->data;
- sptr = array->data;
- hptr = h->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
+ hptr = h->base_addr;
if (bound)
- bptr = bound->data;
+ bptr = bound->base_addr;
else
bptr = NULL;
/* Implementation of the EOSHIFT intrinsic
- Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
else
which = 0;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
int i;
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
ret->offset = 0;
ret->dtype = array->dtype;
for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
}
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
}
else if (unlikely (compile_options.bounds_check))
sstride0 = sstride[0];
hstride0 = hstride[0];
bstride0 = bstride[0];
- rptr = ret->data;
- sptr = array->data;
- hptr = h->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
+ hptr = h->base_addr;
if (bound)
- bptr = bound->data;
+ bptr = bound->base_addr;
else
bptr = NULL;
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
}
if (packed)
- return source->data;
+ return source->base_addr;
/* Allocate storage for the destination. */
destptr = (GFC_COMPLEX_10 *)internal_malloc_size (ssize * sizeof (GFC_COMPLEX_10));
dest = destptr;
- src = source->data;
+ src = source->base_addr;
stride0 = stride[0];
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
}
if (packed)
- return source->data;
+ return source->base_addr;
/* Allocate storage for the destination. */
destptr = (GFC_COMPLEX_16 *)internal_malloc_size (ssize * sizeof (GFC_COMPLEX_16));
dest = destptr;
- src = source->data;
+ src = source->base_addr;
stride0 = stride[0];
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
}
if (packed)
- return source->data;
+ return source->base_addr;
/* Allocate storage for the destination. */
destptr = (GFC_COMPLEX_4 *)internal_malloc_size (ssize * sizeof (GFC_COMPLEX_4));
dest = destptr;
- src = source->data;
+ src = source->base_addr;
stride0 = stride[0];
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
}
if (packed)
- return source->data;
+ return source->base_addr;
/* Allocate storage for the destination. */
destptr = (GFC_COMPLEX_8 *)internal_malloc_size (ssize * sizeof (GFC_COMPLEX_8));
dest = destptr;
- src = source->data;
+ src = source->base_addr;
stride0 = stride[0];
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
}
if (packed)
- return source->data;
+ return source->base_addr;
/* Allocate storage for the destination. */
destptr = (GFC_INTEGER_1 *)internal_malloc_size (ssize * sizeof (GFC_INTEGER_1));
dest = destptr;
- src = source->data;
+ src = source->base_addr;
stride0 = stride[0];
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
}
if (packed)
- return source->data;
+ return source->base_addr;
/* Allocate storage for the destination. */
destptr = (GFC_INTEGER_16 *)internal_malloc_size (ssize * sizeof (GFC_INTEGER_16));
dest = destptr;
- src = source->data;
+ src = source->base_addr;
stride0 = stride[0];
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
}
if (packed)
- return source->data;
+ return source->base_addr;
/* Allocate storage for the destination. */
destptr = (GFC_INTEGER_2 *)internal_malloc_size (ssize * sizeof (GFC_INTEGER_2));
dest = destptr;
- src = source->data;
+ src = source->base_addr;
stride0 = stride[0];
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
}
if (packed)
- return source->data;
+ return source->base_addr;
/* Allocate storage for the destination. */
destptr = (GFC_INTEGER_4 *)internal_malloc_size (ssize * sizeof (GFC_INTEGER_4));
dest = destptr;
- src = source->data;
+ src = source->base_addr;
stride0 = stride[0];
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
}
if (packed)
- return source->data;
+ return source->base_addr;
/* Allocate storage for the destination. */
destptr = (GFC_INTEGER_8 *)internal_malloc_size (ssize * sizeof (GFC_INTEGER_8));
dest = destptr;
- src = source->data;
+ src = source->base_addr;
stride0 = stride[0];
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
}
if (packed)
- return source->data;
+ return source->base_addr;
/* Allocate storage for the destination. */
destptr = (GFC_REAL_10 *)internal_malloc_size (ssize * sizeof (GFC_REAL_10));
dest = destptr;
- src = source->data;
+ src = source->base_addr;
stride0 = stride[0];
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
}
if (packed)
- return source->data;
+ return source->base_addr;
/* Allocate storage for the destination. */
destptr = (GFC_REAL_16 *)internal_malloc_size (ssize * sizeof (GFC_REAL_16));
dest = destptr;
- src = source->data;
+ src = source->base_addr;
stride0 = stride[0];
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
}
if (packed)
- return source->data;
+ return source->base_addr;
/* Allocate storage for the destination. */
destptr = (GFC_REAL_4 *)internal_malloc_size (ssize * sizeof (GFC_REAL_4));
dest = destptr;
- src = source->data;
+ src = source->base_addr;
stride0 = stride[0];
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
}
if (packed)
- return source->data;
+ return source->base_addr;
/* Allocate storage for the destination. */
destptr = (GFC_REAL_8 *)internal_malloc_size (ssize * sizeof (GFC_REAL_8));
dest = destptr;
- src = source->data;
+ src = source->base_addr;
stride0 = stride[0];
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
GFC_COMPLEX_10 * restrict dest;
int n;
- dest = d->data;
+ dest = d->base_addr;
if (src == dest || !src)
return;
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
GFC_COMPLEX_16 * restrict dest;
int n;
- dest = d->data;
+ dest = d->base_addr;
if (src == dest || !src)
return;
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
GFC_COMPLEX_4 * restrict dest;
int n;
- dest = d->data;
+ dest = d->base_addr;
if (src == dest || !src)
return;
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
GFC_COMPLEX_8 * restrict dest;
int n;
- dest = d->data;
+ dest = d->base_addr;
if (src == dest || !src)
return;
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
GFC_INTEGER_1 * restrict dest;
int n;
- dest = d->data;
+ dest = d->base_addr;
if (src == dest || !src)
return;
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
GFC_INTEGER_16 * restrict dest;
int n;
- dest = d->data;
+ dest = d->base_addr;
if (src == dest || !src)
return;
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
GFC_INTEGER_2 * restrict dest;
int n;
- dest = d->data;
+ dest = d->base_addr;
if (src == dest || !src)
return;
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
GFC_INTEGER_4 * restrict dest;
int n;
- dest = d->data;
+ dest = d->base_addr;
if (src == dest || !src)
return;
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
GFC_INTEGER_8 * restrict dest;
int n;
- dest = d->data;
+ dest = d->base_addr;
if (src == dest || !src)
return;
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
GFC_REAL_10 * restrict dest;
int n;
- dest = d->data;
+ dest = d->base_addr;
if (src == dest || !src)
return;
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
GFC_REAL_16 * restrict dest;
int n;
- dest = d->data;
+ dest = d->base_addr;
if (src == dest || !src)
return;
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
GFC_REAL_4 * restrict dest;
int n;
- dest = d->data;
+ dest = d->base_addr;
if (src == dest || !src)
return;
/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
GFC_REAL_8 * restrict dest;
int n;
- dest = d->data;
+ dest = d->base_addr;
if (src == dest || !src)
return;
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dimensioned [count, 1], so ycount=1.
*/
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof (GFC_COMPLEX_10) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
ycount = GFC_DESCRIPTOR_EXTENT(b,1);
}
- abase = a->data;
- bbase = b->data;
- dest = retarray->data;
+ abase = a->base_addr;
+ bbase = b->base_addr;
+ dest = retarray->base_addr;
/* Now that everything is set up, we're performing the multiplication
/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dimensioned [count, 1], so ycount=1.
*/
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof (GFC_COMPLEX_16) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
ycount = GFC_DESCRIPTOR_EXTENT(b,1);
}
- abase = a->data;
- bbase = b->data;
- dest = retarray->data;
+ abase = a->base_addr;
+ bbase = b->base_addr;
+ dest = retarray->base_addr;
/* Now that everything is set up, we're performing the multiplication
/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dimensioned [count, 1], so ycount=1.
*/
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof (GFC_COMPLEX_4) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
ycount = GFC_DESCRIPTOR_EXTENT(b,1);
}
- abase = a->data;
- bbase = b->data;
- dest = retarray->data;
+ abase = a->base_addr;
+ bbase = b->base_addr;
+ dest = retarray->base_addr;
/* Now that everything is set up, we're performing the multiplication
/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dimensioned [count, 1], so ycount=1.
*/
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof (GFC_COMPLEX_8) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
ycount = GFC_DESCRIPTOR_EXTENT(b,1);
}
- abase = a->data;
- bbase = b->data;
- dest = retarray->data;
+ abase = a->base_addr;
+ bbase = b->base_addr;
+ dest = retarray->base_addr;
/* Now that everything is set up, we're performing the multiplication
/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dimensioned [count, 1], so ycount=1.
*/
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof (GFC_INTEGER_1) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
ycount = GFC_DESCRIPTOR_EXTENT(b,1);
}
- abase = a->data;
- bbase = b->data;
- dest = retarray->data;
+ abase = a->base_addr;
+ bbase = b->base_addr;
+ dest = retarray->base_addr;
/* Now that everything is set up, we're performing the multiplication
/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dimensioned [count, 1], so ycount=1.
*/
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof (GFC_INTEGER_16) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
ycount = GFC_DESCRIPTOR_EXTENT(b,1);
}
- abase = a->data;
- bbase = b->data;
- dest = retarray->data;
+ abase = a->base_addr;
+ bbase = b->base_addr;
+ dest = retarray->base_addr;
/* Now that everything is set up, we're performing the multiplication
/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dimensioned [count, 1], so ycount=1.
*/
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof (GFC_INTEGER_2) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
ycount = GFC_DESCRIPTOR_EXTENT(b,1);
}
- abase = a->data;
- bbase = b->data;
- dest = retarray->data;
+ abase = a->base_addr;
+ bbase = b->base_addr;
+ dest = retarray->base_addr;
/* Now that everything is set up, we're performing the multiplication
/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dimensioned [count, 1], so ycount=1.
*/
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof (GFC_INTEGER_4) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
ycount = GFC_DESCRIPTOR_EXTENT(b,1);
}
- abase = a->data;
- bbase = b->data;
- dest = retarray->data;
+ abase = a->base_addr;
+ bbase = b->base_addr;
+ dest = retarray->base_addr;
/* Now that everything is set up, we're performing the multiplication
/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dimensioned [count, 1], so ycount=1.
*/
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof (GFC_INTEGER_8) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
ycount = GFC_DESCRIPTOR_EXTENT(b,1);
}
- abase = a->data;
- bbase = b->data;
- dest = retarray->data;
+ abase = a->base_addr;
+ bbase = b->base_addr;
+ dest = retarray->base_addr;
/* Now that everything is set up, we're performing the multiplication
/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
assert (GFC_DESCRIPTOR_RANK (a) == 2
|| GFC_DESCRIPTOR_RANK (b) == 2);
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof (GFC_LOGICAL_16) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
}
}
- abase = a->data;
+ abase = a->base_addr;
a_kind = GFC_DESCRIPTOR_SIZE (a);
if (a_kind == 1 || a_kind == 2 || a_kind == 4 || a_kind == 8
else
internal_error (NULL, "Funny sized logical array");
- bbase = b->data;
+ bbase = b->base_addr;
b_kind = GFC_DESCRIPTOR_SIZE (b);
if (b_kind == 1 || b_kind == 2 || b_kind == 4 || b_kind == 8
else
internal_error (NULL, "Funny sized logical array");
- dest = retarray->data;
+ dest = retarray->base_addr;
if (GFC_DESCRIPTOR_RANK (retarray) == 1)
/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
assert (GFC_DESCRIPTOR_RANK (a) == 2
|| GFC_DESCRIPTOR_RANK (b) == 2);
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof (GFC_LOGICAL_4) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
}
}
- abase = a->data;
+ abase = a->base_addr;
a_kind = GFC_DESCRIPTOR_SIZE (a);
if (a_kind == 1 || a_kind == 2 || a_kind == 4 || a_kind == 8
else
internal_error (NULL, "Funny sized logical array");
- bbase = b->data;
+ bbase = b->base_addr;
b_kind = GFC_DESCRIPTOR_SIZE (b);
if (b_kind == 1 || b_kind == 2 || b_kind == 4 || b_kind == 8
else
internal_error (NULL, "Funny sized logical array");
- dest = retarray->data;
+ dest = retarray->base_addr;
if (GFC_DESCRIPTOR_RANK (retarray) == 1)
/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
assert (GFC_DESCRIPTOR_RANK (a) == 2
|| GFC_DESCRIPTOR_RANK (b) == 2);
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof (GFC_LOGICAL_8) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
}
}
- abase = a->data;
+ abase = a->base_addr;
a_kind = GFC_DESCRIPTOR_SIZE (a);
if (a_kind == 1 || a_kind == 2 || a_kind == 4 || a_kind == 8
else
internal_error (NULL, "Funny sized logical array");
- bbase = b->data;
+ bbase = b->base_addr;
b_kind = GFC_DESCRIPTOR_SIZE (b);
if (b_kind == 1 || b_kind == 2 || b_kind == 4 || b_kind == 8
else
internal_error (NULL, "Funny sized logical array");
- dest = retarray->data;
+ dest = retarray->base_addr;
if (GFC_DESCRIPTOR_RANK (retarray) == 1)
/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dimensioned [count, 1], so ycount=1.
*/
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof (GFC_REAL_10) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
ycount = GFC_DESCRIPTOR_EXTENT(b,1);
}
- abase = a->data;
- bbase = b->data;
- dest = retarray->data;
+ abase = a->base_addr;
+ bbase = b->base_addr;
+ dest = retarray->base_addr;
/* Now that everything is set up, we're performing the multiplication
/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dimensioned [count, 1], so ycount=1.
*/
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof (GFC_REAL_16) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
ycount = GFC_DESCRIPTOR_EXTENT(b,1);
}
- abase = a->data;
- bbase = b->data;
- dest = retarray->data;
+ abase = a->base_addr;
+ bbase = b->base_addr;
+ dest = retarray->base_addr;
/* Now that everything is set up, we're performing the multiplication
/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dimensioned [count, 1], so ycount=1.
*/
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof (GFC_REAL_4) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
ycount = GFC_DESCRIPTOR_EXTENT(b,1);
}
- abase = a->data;
- bbase = b->data;
- dest = retarray->data;
+ abase = a->base_addr;
+ bbase = b->base_addr;
+ dest = retarray->base_addr;
/* Now that everything is set up, we're performing the multiplication
/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dimensioned [count, 1], so ycount=1.
*/
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof (GFC_REAL_8) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
ycount = GFC_DESCRIPTOR_EXTENT(b,1);
}
- abase = a->data;
- bbase = b->data;
- dest = retarray->data;
+ abase = a->base_addr;
+ bbase = b->base_addr;
+ dest = retarray->base_addr;
/* Now that everything is set up, we're performing the multiplication
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = 0 ;
}
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
/* Specific implementation of the PACK intrinsic
- Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+ Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
if (zero_sized)
sptr = NULL;
else
- sptr = array->data;
+ sptr = array->base_addr;
- if (ret->data == NULL || unlikely (compile_options.bounds_check))
+ if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
total = count_0 (mask);
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* Setup the array descriptor. */
GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (sizeof (GFC_COMPLEX_10) * total);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_10) * total);
if (total == 0)
return;
rstride0 = 1;
sstride0 = sstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
+ rptr = ret->base_addr;
while (sptr && mptr)
{
if (vector)
{
n = GFC_DESCRIPTOR_EXTENT(vector,0);
- nelem = ((rptr - ret->data) / rstride0);
+ nelem = ((rptr - ret->base_addr) / rstride0);
if (n > nelem)
{
sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
if (sstride0 == 0)
sstride0 = 1;
- sptr = vector->data + sstride0 * nelem;
+ sptr = vector->base_addr + sstride0 * nelem;
n -= nelem;
while (n--)
{
/* Specific implementation of the PACK intrinsic
- Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+ Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
if (zero_sized)
sptr = NULL;
else
- sptr = array->data;
+ sptr = array->base_addr;
- if (ret->data == NULL || unlikely (compile_options.bounds_check))
+ if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
total = count_0 (mask);
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* Setup the array descriptor. */
GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (sizeof (GFC_COMPLEX_16) * total);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_16) * total);
if (total == 0)
return;
rstride0 = 1;
sstride0 = sstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
+ rptr = ret->base_addr;
while (sptr && mptr)
{
if (vector)
{
n = GFC_DESCRIPTOR_EXTENT(vector,0);
- nelem = ((rptr - ret->data) / rstride0);
+ nelem = ((rptr - ret->base_addr) / rstride0);
if (n > nelem)
{
sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
if (sstride0 == 0)
sstride0 = 1;
- sptr = vector->data + sstride0 * nelem;
+ sptr = vector->base_addr + sstride0 * nelem;
n -= nelem;
while (n--)
{
/* Specific implementation of the PACK intrinsic
- Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+ Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
if (zero_sized)
sptr = NULL;
else
- sptr = array->data;
+ sptr = array->base_addr;
- if (ret->data == NULL || unlikely (compile_options.bounds_check))
+ if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
total = count_0 (mask);
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* Setup the array descriptor. */
GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (sizeof (GFC_COMPLEX_4) * total);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_4) * total);
if (total == 0)
return;
rstride0 = 1;
sstride0 = sstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
+ rptr = ret->base_addr;
while (sptr && mptr)
{
if (vector)
{
n = GFC_DESCRIPTOR_EXTENT(vector,0);
- nelem = ((rptr - ret->data) / rstride0);
+ nelem = ((rptr - ret->base_addr) / rstride0);
if (n > nelem)
{
sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
if (sstride0 == 0)
sstride0 = 1;
- sptr = vector->data + sstride0 * nelem;
+ sptr = vector->base_addr + sstride0 * nelem;
n -= nelem;
while (n--)
{
/* Specific implementation of the PACK intrinsic
- Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+ Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
if (zero_sized)
sptr = NULL;
else
- sptr = array->data;
+ sptr = array->base_addr;
- if (ret->data == NULL || unlikely (compile_options.bounds_check))
+ if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
total = count_0 (mask);
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* Setup the array descriptor. */
GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (sizeof (GFC_COMPLEX_8) * total);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_8) * total);
if (total == 0)
return;
rstride0 = 1;
sstride0 = sstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
+ rptr = ret->base_addr;
while (sptr && mptr)
{
if (vector)
{
n = GFC_DESCRIPTOR_EXTENT(vector,0);
- nelem = ((rptr - ret->data) / rstride0);
+ nelem = ((rptr - ret->base_addr) / rstride0);
if (n > nelem)
{
sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
if (sstride0 == 0)
sstride0 = 1;
- sptr = vector->data + sstride0 * nelem;
+ sptr = vector->base_addr + sstride0 * nelem;
n -= nelem;
while (n--)
{
/* Specific implementation of the PACK intrinsic
- Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+ Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
if (zero_sized)
sptr = NULL;
else
- sptr = array->data;
+ sptr = array->base_addr;
- if (ret->data == NULL || unlikely (compile_options.bounds_check))
+ if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
total = count_0 (mask);
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* Setup the array descriptor. */
GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (sizeof (GFC_INTEGER_1) * total);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_1) * total);
if (total == 0)
return;
rstride0 = 1;
sstride0 = sstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
+ rptr = ret->base_addr;
while (sptr && mptr)
{
if (vector)
{
n = GFC_DESCRIPTOR_EXTENT(vector,0);
- nelem = ((rptr - ret->data) / rstride0);
+ nelem = ((rptr - ret->base_addr) / rstride0);
if (n > nelem)
{
sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
if (sstride0 == 0)
sstride0 = 1;
- sptr = vector->data + sstride0 * nelem;
+ sptr = vector->base_addr + sstride0 * nelem;
n -= nelem;
while (n--)
{
/* Specific implementation of the PACK intrinsic
- Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+ Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
if (zero_sized)
sptr = NULL;
else
- sptr = array->data;
+ sptr = array->base_addr;
- if (ret->data == NULL || unlikely (compile_options.bounds_check))
+ if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
total = count_0 (mask);
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* Setup the array descriptor. */
GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * total);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * total);
if (total == 0)
return;
rstride0 = 1;
sstride0 = sstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
+ rptr = ret->base_addr;
while (sptr && mptr)
{
if (vector)
{
n = GFC_DESCRIPTOR_EXTENT(vector,0);
- nelem = ((rptr - ret->data) / rstride0);
+ nelem = ((rptr - ret->base_addr) / rstride0);
if (n > nelem)
{
sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
if (sstride0 == 0)
sstride0 = 1;
- sptr = vector->data + sstride0 * nelem;
+ sptr = vector->base_addr + sstride0 * nelem;
n -= nelem;
while (n--)
{
/* Specific implementation of the PACK intrinsic
- Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+ Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
if (zero_sized)
sptr = NULL;
else
- sptr = array->data;
+ sptr = array->base_addr;
- if (ret->data == NULL || unlikely (compile_options.bounds_check))
+ if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
total = count_0 (mask);
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* Setup the array descriptor. */
GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (sizeof (GFC_INTEGER_2) * total);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_2) * total);
if (total == 0)
return;
rstride0 = 1;
sstride0 = sstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
+ rptr = ret->base_addr;
while (sptr && mptr)
{
if (vector)
{
n = GFC_DESCRIPTOR_EXTENT(vector,0);
- nelem = ((rptr - ret->data) / rstride0);
+ nelem = ((rptr - ret->base_addr) / rstride0);
if (n > nelem)
{
sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
if (sstride0 == 0)
sstride0 = 1;
- sptr = vector->data + sstride0 * nelem;
+ sptr = vector->base_addr + sstride0 * nelem;
n -= nelem;
while (n--)
{
/* Specific implementation of the PACK intrinsic
- Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+ Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
if (zero_sized)
sptr = NULL;
else
- sptr = array->data;
+ sptr = array->base_addr;
- if (ret->data == NULL || unlikely (compile_options.bounds_check))
+ if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
total = count_0 (mask);
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* Setup the array descriptor. */
GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * total);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * total);
if (total == 0)
return;
rstride0 = 1;
sstride0 = sstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
+ rptr = ret->base_addr;
while (sptr && mptr)
{
if (vector)
{
n = GFC_DESCRIPTOR_EXTENT(vector,0);
- nelem = ((rptr - ret->data) / rstride0);
+ nelem = ((rptr - ret->base_addr) / rstride0);
if (n > nelem)
{
sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
if (sstride0 == 0)
sstride0 = 1;
- sptr = vector->data + sstride0 * nelem;
+ sptr = vector->base_addr + sstride0 * nelem;
n -= nelem;
while (n--)
{
/* Specific implementation of the PACK intrinsic
- Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+ Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
if (zero_sized)
sptr = NULL;
else
- sptr = array->data;
+ sptr = array->base_addr;
- if (ret->data == NULL || unlikely (compile_options.bounds_check))
+ if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
total = count_0 (mask);
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* Setup the array descriptor. */
GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * total);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * total);
if (total == 0)
return;
rstride0 = 1;
sstride0 = sstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
+ rptr = ret->base_addr;
while (sptr && mptr)
{
if (vector)
{
n = GFC_DESCRIPTOR_EXTENT(vector,0);
- nelem = ((rptr - ret->data) / rstride0);
+ nelem = ((rptr - ret->base_addr) / rstride0);
if (n > nelem)
{
sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
if (sstride0 == 0)
sstride0 = 1;
- sptr = vector->data + sstride0 * nelem;
+ sptr = vector->base_addr + sstride0 * nelem;
n -= nelem;
while (n--)
{
/* Specific implementation of the PACK intrinsic
- Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+ Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
if (zero_sized)
sptr = NULL;
else
- sptr = array->data;
+ sptr = array->base_addr;
- if (ret->data == NULL || unlikely (compile_options.bounds_check))
+ if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
total = count_0 (mask);
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* Setup the array descriptor. */
GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (sizeof (GFC_REAL_10) * total);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_10) * total);
if (total == 0)
return;
rstride0 = 1;
sstride0 = sstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
+ rptr = ret->base_addr;
while (sptr && mptr)
{
if (vector)
{
n = GFC_DESCRIPTOR_EXTENT(vector,0);
- nelem = ((rptr - ret->data) / rstride0);
+ nelem = ((rptr - ret->base_addr) / rstride0);
if (n > nelem)
{
sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
if (sstride0 == 0)
sstride0 = 1;
- sptr = vector->data + sstride0 * nelem;
+ sptr = vector->base_addr + sstride0 * nelem;
n -= nelem;
while (n--)
{
/* Specific implementation of the PACK intrinsic
- Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+ Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
if (zero_sized)
sptr = NULL;
else
- sptr = array->data;
+ sptr = array->base_addr;
- if (ret->data == NULL || unlikely (compile_options.bounds_check))
+ if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
total = count_0 (mask);
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* Setup the array descriptor. */
GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (sizeof (GFC_REAL_16) * total);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_16) * total);
if (total == 0)
return;
rstride0 = 1;
sstride0 = sstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
+ rptr = ret->base_addr;
while (sptr && mptr)
{
if (vector)
{
n = GFC_DESCRIPTOR_EXTENT(vector,0);
- nelem = ((rptr - ret->data) / rstride0);
+ nelem = ((rptr - ret->base_addr) / rstride0);
if (n > nelem)
{
sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
if (sstride0 == 0)
sstride0 = 1;
- sptr = vector->data + sstride0 * nelem;
+ sptr = vector->base_addr + sstride0 * nelem;
n -= nelem;
while (n--)
{
/* Specific implementation of the PACK intrinsic
- Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+ Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
if (zero_sized)
sptr = NULL;
else
- sptr = array->data;
+ sptr = array->base_addr;
- if (ret->data == NULL || unlikely (compile_options.bounds_check))
+ if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
total = count_0 (mask);
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* Setup the array descriptor. */
GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (sizeof (GFC_REAL_4) * total);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_4) * total);
if (total == 0)
return;
rstride0 = 1;
sstride0 = sstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
+ rptr = ret->base_addr;
while (sptr && mptr)
{
if (vector)
{
n = GFC_DESCRIPTOR_EXTENT(vector,0);
- nelem = ((rptr - ret->data) / rstride0);
+ nelem = ((rptr - ret->base_addr) / rstride0);
if (n > nelem)
{
sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
if (sstride0 == 0)
sstride0 = 1;
- sptr = vector->data + sstride0 * nelem;
+ sptr = vector->base_addr + sstride0 * nelem;
n -= nelem;
while (n--)
{
/* Specific implementation of the PACK intrinsic
- Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+ Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
if (zero_sized)
sptr = NULL;
else
- sptr = array->data;
+ sptr = array->base_addr;
- if (ret->data == NULL || unlikely (compile_options.bounds_check))
+ if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
total = count_0 (mask);
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* Setup the array descriptor. */
GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (sizeof (GFC_REAL_8) * total);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_8) * total);
if (total == 0)
return;
rstride0 = 1;
sstride0 = sstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
+ rptr = ret->base_addr;
while (sptr && mptr)
{
if (vector)
{
n = GFC_DESCRIPTOR_EXTENT(vector,0);
- nelem = ((rptr - ret->data) / rstride0);
+ nelem = ((rptr - ret->base_addr) / rstride0);
if (n > nelem)
{
sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
if (sstride0 == 0)
sstride0 = 1;
- sptr = vector->data + sstride0 * nelem;
+ sptr = vector->base_addr + sstride0 * nelem;
n -= nelem;
while (n--)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_LOGICAL_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_LOGICAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_LOGICAL_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_LOGICAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_LOGICAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- else
- retarray->data = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_COMPLEX_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_COMPLEX_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_COMPLEX_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_COMPLEX_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
/* Implementation of the RESHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
for (n = 0; n < rdim; n++)
{
- shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+ shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
{
shape_data[n] = 0;
}
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
index_type alloc_size;
else
alloc_size = rs * sizeof (GFC_COMPLEX_10);
- ret->data = internal_malloc_size (alloc_size);
+ ret->base_addr = internal_malloc_size (alloc_size);
ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
}
else
psize = 0;
}
- pptr = pad->data;
+ pptr = pad->base_addr;
}
else
{
for (n = 0; n < rdim; n++)
{
- v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
if (v < 0 || v >= rdim)
runtime_error("Value %ld out of range in ORDER argument"
for (n = 0; n < rdim; n++)
{
if (order)
- dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
dim = n;
rsize *= sizeof (GFC_COMPLEX_10);
ssize *= sizeof (GFC_COMPLEX_10);
psize *= sizeof (GFC_COMPLEX_10);
- reshape_packed ((char *)ret->data, rsize, (char *)source->data,
- ssize, pad ? (char *)pad->data : NULL, psize);
+ reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+ ssize, pad ? (char *)pad->base_addr : NULL, psize);
return;
}
- rptr = ret->data;
- src = sptr = source->data;
+ rptr = ret->base_addr;
+ src = sptr = source->base_addr;
rstride0 = rstride[0];
sstride0 = sstride[0];
/* Implementation of the RESHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
for (n = 0; n < rdim; n++)
{
- shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+ shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
{
shape_data[n] = 0;
}
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
index_type alloc_size;
else
alloc_size = rs * sizeof (GFC_COMPLEX_16);
- ret->data = internal_malloc_size (alloc_size);
+ ret->base_addr = internal_malloc_size (alloc_size);
ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
}
else
psize = 0;
}
- pptr = pad->data;
+ pptr = pad->base_addr;
}
else
{
for (n = 0; n < rdim; n++)
{
- v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
if (v < 0 || v >= rdim)
runtime_error("Value %ld out of range in ORDER argument"
for (n = 0; n < rdim; n++)
{
if (order)
- dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
dim = n;
rsize *= sizeof (GFC_COMPLEX_16);
ssize *= sizeof (GFC_COMPLEX_16);
psize *= sizeof (GFC_COMPLEX_16);
- reshape_packed ((char *)ret->data, rsize, (char *)source->data,
- ssize, pad ? (char *)pad->data : NULL, psize);
+ reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+ ssize, pad ? (char *)pad->base_addr : NULL, psize);
return;
}
- rptr = ret->data;
- src = sptr = source->data;
+ rptr = ret->base_addr;
+ src = sptr = source->base_addr;
rstride0 = rstride[0];
sstride0 = sstride[0];
/* Implementation of the RESHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
for (n = 0; n < rdim; n++)
{
- shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+ shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
{
shape_data[n] = 0;
}
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
index_type alloc_size;
else
alloc_size = rs * sizeof (GFC_COMPLEX_4);
- ret->data = internal_malloc_size (alloc_size);
+ ret->base_addr = internal_malloc_size (alloc_size);
ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
}
else
psize = 0;
}
- pptr = pad->data;
+ pptr = pad->base_addr;
}
else
{
for (n = 0; n < rdim; n++)
{
- v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
if (v < 0 || v >= rdim)
runtime_error("Value %ld out of range in ORDER argument"
for (n = 0; n < rdim; n++)
{
if (order)
- dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
dim = n;
rsize *= sizeof (GFC_COMPLEX_4);
ssize *= sizeof (GFC_COMPLEX_4);
psize *= sizeof (GFC_COMPLEX_4);
- reshape_packed ((char *)ret->data, rsize, (char *)source->data,
- ssize, pad ? (char *)pad->data : NULL, psize);
+ reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+ ssize, pad ? (char *)pad->base_addr : NULL, psize);
return;
}
- rptr = ret->data;
- src = sptr = source->data;
+ rptr = ret->base_addr;
+ src = sptr = source->base_addr;
rstride0 = rstride[0];
sstride0 = sstride[0];
/* Implementation of the RESHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
for (n = 0; n < rdim; n++)
{
- shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+ shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
{
shape_data[n] = 0;
}
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
index_type alloc_size;
else
alloc_size = rs * sizeof (GFC_COMPLEX_8);
- ret->data = internal_malloc_size (alloc_size);
+ ret->base_addr = internal_malloc_size (alloc_size);
ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
}
else
psize = 0;
}
- pptr = pad->data;
+ pptr = pad->base_addr;
}
else
{
for (n = 0; n < rdim; n++)
{
- v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
if (v < 0 || v >= rdim)
runtime_error("Value %ld out of range in ORDER argument"
for (n = 0; n < rdim; n++)
{
if (order)
- dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
dim = n;
rsize *= sizeof (GFC_COMPLEX_8);
ssize *= sizeof (GFC_COMPLEX_8);
psize *= sizeof (GFC_COMPLEX_8);
- reshape_packed ((char *)ret->data, rsize, (char *)source->data,
- ssize, pad ? (char *)pad->data : NULL, psize);
+ reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+ ssize, pad ? (char *)pad->base_addr : NULL, psize);
return;
}
- rptr = ret->data;
- src = sptr = source->data;
+ rptr = ret->base_addr;
+ src = sptr = source->base_addr;
rstride0 = rstride[0];
sstride0 = sstride[0];
/* Implementation of the RESHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
for (n = 0; n < rdim; n++)
{
- shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+ shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
{
shape_data[n] = 0;
}
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
index_type alloc_size;
else
alloc_size = rs * sizeof (GFC_INTEGER_16);
- ret->data = internal_malloc_size (alloc_size);
+ ret->base_addr = internal_malloc_size (alloc_size);
ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
}
else
psize = 0;
}
- pptr = pad->data;
+ pptr = pad->base_addr;
}
else
{
for (n = 0; n < rdim; n++)
{
- v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
if (v < 0 || v >= rdim)
runtime_error("Value %ld out of range in ORDER argument"
for (n = 0; n < rdim; n++)
{
if (order)
- dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
dim = n;
rsize *= sizeof (GFC_INTEGER_16);
ssize *= sizeof (GFC_INTEGER_16);
psize *= sizeof (GFC_INTEGER_16);
- reshape_packed ((char *)ret->data, rsize, (char *)source->data,
- ssize, pad ? (char *)pad->data : NULL, psize);
+ reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+ ssize, pad ? (char *)pad->base_addr : NULL, psize);
return;
}
- rptr = ret->data;
- src = sptr = source->data;
+ rptr = ret->base_addr;
+ src = sptr = source->base_addr;
rstride0 = rstride[0];
sstride0 = sstride[0];
/* Implementation of the RESHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
for (n = 0; n < rdim; n++)
{
- shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+ shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
{
shape_data[n] = 0;
}
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
index_type alloc_size;
else
alloc_size = rs * sizeof (GFC_INTEGER_4);
- ret->data = internal_malloc_size (alloc_size);
+ ret->base_addr = internal_malloc_size (alloc_size);
ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
}
else
psize = 0;
}
- pptr = pad->data;
+ pptr = pad->base_addr;
}
else
{
for (n = 0; n < rdim; n++)
{
- v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
if (v < 0 || v >= rdim)
runtime_error("Value %ld out of range in ORDER argument"
for (n = 0; n < rdim; n++)
{
if (order)
- dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
dim = n;
rsize *= sizeof (GFC_INTEGER_4);
ssize *= sizeof (GFC_INTEGER_4);
psize *= sizeof (GFC_INTEGER_4);
- reshape_packed ((char *)ret->data, rsize, (char *)source->data,
- ssize, pad ? (char *)pad->data : NULL, psize);
+ reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+ ssize, pad ? (char *)pad->base_addr : NULL, psize);
return;
}
- rptr = ret->data;
- src = sptr = source->data;
+ rptr = ret->base_addr;
+ src = sptr = source->base_addr;
rstride0 = rstride[0];
sstride0 = sstride[0];
/* Implementation of the RESHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
for (n = 0; n < rdim; n++)
{
- shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+ shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
{
shape_data[n] = 0;
}
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
index_type alloc_size;
else
alloc_size = rs * sizeof (GFC_INTEGER_8);
- ret->data = internal_malloc_size (alloc_size);
+ ret->base_addr = internal_malloc_size (alloc_size);
ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
}
else
psize = 0;
}
- pptr = pad->data;
+ pptr = pad->base_addr;
}
else
{
for (n = 0; n < rdim; n++)
{
- v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
if (v < 0 || v >= rdim)
runtime_error("Value %ld out of range in ORDER argument"
for (n = 0; n < rdim; n++)
{
if (order)
- dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
dim = n;
rsize *= sizeof (GFC_INTEGER_8);
ssize *= sizeof (GFC_INTEGER_8);
psize *= sizeof (GFC_INTEGER_8);
- reshape_packed ((char *)ret->data, rsize, (char *)source->data,
- ssize, pad ? (char *)pad->data : NULL, psize);
+ reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+ ssize, pad ? (char *)pad->base_addr : NULL, psize);
return;
}
- rptr = ret->data;
- src = sptr = source->data;
+ rptr = ret->base_addr;
+ src = sptr = source->base_addr;
rstride0 = rstride[0];
sstride0 = sstride[0];
/* Implementation of the RESHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
for (n = 0; n < rdim; n++)
{
- shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+ shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
{
shape_data[n] = 0;
}
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
index_type alloc_size;
else
alloc_size = rs * sizeof (GFC_REAL_10);
- ret->data = internal_malloc_size (alloc_size);
+ ret->base_addr = internal_malloc_size (alloc_size);
ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
}
else
psize = 0;
}
- pptr = pad->data;
+ pptr = pad->base_addr;
}
else
{
for (n = 0; n < rdim; n++)
{
- v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
if (v < 0 || v >= rdim)
runtime_error("Value %ld out of range in ORDER argument"
for (n = 0; n < rdim; n++)
{
if (order)
- dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
dim = n;
rsize *= sizeof (GFC_REAL_10);
ssize *= sizeof (GFC_REAL_10);
psize *= sizeof (GFC_REAL_10);
- reshape_packed ((char *)ret->data, rsize, (char *)source->data,
- ssize, pad ? (char *)pad->data : NULL, psize);
+ reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+ ssize, pad ? (char *)pad->base_addr : NULL, psize);
return;
}
- rptr = ret->data;
- src = sptr = source->data;
+ rptr = ret->base_addr;
+ src = sptr = source->base_addr;
rstride0 = rstride[0];
sstride0 = sstride[0];
/* Implementation of the RESHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
for (n = 0; n < rdim; n++)
{
- shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+ shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
{
shape_data[n] = 0;
}
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
index_type alloc_size;
else
alloc_size = rs * sizeof (GFC_REAL_16);
- ret->data = internal_malloc_size (alloc_size);
+ ret->base_addr = internal_malloc_size (alloc_size);
ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
}
else
psize = 0;
}
- pptr = pad->data;
+ pptr = pad->base_addr;
}
else
{
for (n = 0; n < rdim; n++)
{
- v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
if (v < 0 || v >= rdim)
runtime_error("Value %ld out of range in ORDER argument"
for (n = 0; n < rdim; n++)
{
if (order)
- dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
dim = n;
rsize *= sizeof (GFC_REAL_16);
ssize *= sizeof (GFC_REAL_16);
psize *= sizeof (GFC_REAL_16);
- reshape_packed ((char *)ret->data, rsize, (char *)source->data,
- ssize, pad ? (char *)pad->data : NULL, psize);
+ reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+ ssize, pad ? (char *)pad->base_addr : NULL, psize);
return;
}
- rptr = ret->data;
- src = sptr = source->data;
+ rptr = ret->base_addr;
+ src = sptr = source->base_addr;
rstride0 = rstride[0];
sstride0 = sstride[0];
/* Implementation of the RESHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
for (n = 0; n < rdim; n++)
{
- shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+ shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
{
shape_data[n] = 0;
}
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
index_type alloc_size;
else
alloc_size = rs * sizeof (GFC_REAL_4);
- ret->data = internal_malloc_size (alloc_size);
+ ret->base_addr = internal_malloc_size (alloc_size);
ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
}
else
psize = 0;
}
- pptr = pad->data;
+ pptr = pad->base_addr;
}
else
{
for (n = 0; n < rdim; n++)
{
- v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
if (v < 0 || v >= rdim)
runtime_error("Value %ld out of range in ORDER argument"
for (n = 0; n < rdim; n++)
{
if (order)
- dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
dim = n;
rsize *= sizeof (GFC_REAL_4);
ssize *= sizeof (GFC_REAL_4);
psize *= sizeof (GFC_REAL_4);
- reshape_packed ((char *)ret->data, rsize, (char *)source->data,
- ssize, pad ? (char *)pad->data : NULL, psize);
+ reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+ ssize, pad ? (char *)pad->base_addr : NULL, psize);
return;
}
- rptr = ret->data;
- src = sptr = source->data;
+ rptr = ret->base_addr;
+ src = sptr = source->base_addr;
rstride0 = rstride[0];
sstride0 = sstride[0];
/* Implementation of the RESHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
for (n = 0; n < rdim; n++)
{
- shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+ shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
{
shape_data[n] = 0;
}
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
index_type alloc_size;
else
alloc_size = rs * sizeof (GFC_REAL_8);
- ret->data = internal_malloc_size (alloc_size);
+ ret->base_addr = internal_malloc_size (alloc_size);
ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
}
else
psize = 0;
}
- pptr = pad->data;
+ pptr = pad->base_addr;
}
else
{
for (n = 0; n < rdim; n++)
{
- v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
if (v < 0 || v >= rdim)
runtime_error("Value %ld out of range in ORDER argument"
for (n = 0; n < rdim; n++)
{
if (order)
- dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
dim = n;
rsize *= sizeof (GFC_REAL_8);
ssize *= sizeof (GFC_REAL_8);
psize *= sizeof (GFC_REAL_8);
- reshape_packed ((char *)ret->data, rsize, (char *)source->data,
- ssize, pad ? (char *)pad->data : NULL, psize);
+ reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+ ssize, pad ? (char *)pad->base_addr : NULL, psize);
return;
}
- rptr = ret->data;
- src = sptr = source->data;
+ rptr = ret->base_addr;
+ src = sptr = source->base_addr;
rstride0 = rstride[0];
sstride0 = sstride[0];
/* Implementation of the SHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2010, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
rank = GFC_DESCRIPTOR_RANK (array);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
GFC_DIMENSION_SET(ret->dim[0], 0, rank - 1, 1);
ret->offset = 0;
- ret->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
}
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < rank; n++)
{
extent = GFC_DESCRIPTOR_EXTENT(array,n);
- ret->data[n * stride] = extent > 0 ? extent : 0 ;
+ ret->base_addr[n * stride] = extent > 0 ? extent : 0 ;
}
}
/* Implementation of the SHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2010, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
rank = GFC_DESCRIPTOR_RANK (array);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
GFC_DIMENSION_SET(ret->dim[0], 0, rank - 1, 1);
ret->offset = 0;
- ret->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
}
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < rank; n++)
{
extent = GFC_DESCRIPTOR_EXTENT(array,n);
- ret->data[n * stride] = extent > 0 ? extent : 0 ;
+ ret->base_addr[n * stride] = extent > 0 ? extent : 0 ;
}
}
/* Implementation of the SHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2010, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
rank = GFC_DESCRIPTOR_RANK (array);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
GFC_DIMENSION_SET(ret->dim[0], 0, rank - 1, 1);
ret->offset = 0;
- ret->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+ ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
}
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < rank; n++)
{
extent = GFC_DESCRIPTOR_EXTENT(array,n);
- ret->data[n * stride] = extent > 0 ? extent : 0 ;
+ ret->base_addr[n * stride] = extent > 0 ? extent : 0 ;
}
}
/* Special implementation of the SPREAD intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
spread_generic.c written by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
ncopies = pncopies;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t ub, stride;
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (rs * sizeof(GFC_COMPLEX_10));
+ ret->base_addr = internal_malloc_size (rs * sizeof(GFC_COMPLEX_10));
if (rs <= 0)
return;
}
}
sstride0 = sstride[0];
rstride0 = rstride[0];
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
while (sptr)
{
if (along > 1)
runtime_error ("dim outside of rank in spread()");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
- ret->data = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_10));
+ ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_10));
ret->offset = 0;
GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
}
runtime_error ("dim too large in spread()");
}
- dest = ret->data;
+ dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < ncopies; n++)
/* Special implementation of the SPREAD intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
spread_generic.c written by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
ncopies = pncopies;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t ub, stride;
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (rs * sizeof(GFC_COMPLEX_16));
+ ret->base_addr = internal_malloc_size (rs * sizeof(GFC_COMPLEX_16));
if (rs <= 0)
return;
}
}
sstride0 = sstride[0];
rstride0 = rstride[0];
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
while (sptr)
{
if (along > 1)
runtime_error ("dim outside of rank in spread()");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
- ret->data = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_16));
+ ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_16));
ret->offset = 0;
GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
}
runtime_error ("dim too large in spread()");
}
- dest = ret->data;
+ dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < ncopies; n++)
/* Special implementation of the SPREAD intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
spread_generic.c written by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
ncopies = pncopies;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t ub, stride;
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (rs * sizeof(GFC_COMPLEX_4));
+ ret->base_addr = internal_malloc_size (rs * sizeof(GFC_COMPLEX_4));
if (rs <= 0)
return;
}
}
sstride0 = sstride[0];
rstride0 = rstride[0];
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
while (sptr)
{
if (along > 1)
runtime_error ("dim outside of rank in spread()");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
- ret->data = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_4));
+ ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_4));
ret->offset = 0;
GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
}
runtime_error ("dim too large in spread()");
}
- dest = ret->data;
+ dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < ncopies; n++)
/* Special implementation of the SPREAD intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
spread_generic.c written by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
ncopies = pncopies;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t ub, stride;
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (rs * sizeof(GFC_COMPLEX_8));
+ ret->base_addr = internal_malloc_size (rs * sizeof(GFC_COMPLEX_8));
if (rs <= 0)
return;
}
}
sstride0 = sstride[0];
rstride0 = rstride[0];
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
while (sptr)
{
if (along > 1)
runtime_error ("dim outside of rank in spread()");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
- ret->data = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_8));
+ ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_8));
ret->offset = 0;
GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
}
runtime_error ("dim too large in spread()");
}
- dest = ret->data;
+ dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < ncopies; n++)
/* Special implementation of the SPREAD intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
spread_generic.c written by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
ncopies = pncopies;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t ub, stride;
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (rs * sizeof(GFC_INTEGER_1));
+ ret->base_addr = internal_malloc_size (rs * sizeof(GFC_INTEGER_1));
if (rs <= 0)
return;
}
}
sstride0 = sstride[0];
rstride0 = rstride[0];
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
while (sptr)
{
if (along > 1)
runtime_error ("dim outside of rank in spread()");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
- ret->data = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_1));
+ ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_1));
ret->offset = 0;
GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
}
runtime_error ("dim too large in spread()");
}
- dest = ret->data;
+ dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < ncopies; n++)
/* Special implementation of the SPREAD intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
spread_generic.c written by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
ncopies = pncopies;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t ub, stride;
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (rs * sizeof(GFC_INTEGER_16));
+ ret->base_addr = internal_malloc_size (rs * sizeof(GFC_INTEGER_16));
if (rs <= 0)
return;
}
}
sstride0 = sstride[0];
rstride0 = rstride[0];
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
while (sptr)
{
if (along > 1)
runtime_error ("dim outside of rank in spread()");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
- ret->data = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_16));
+ ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_16));
ret->offset = 0;
GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
}
runtime_error ("dim too large in spread()");
}
- dest = ret->data;
+ dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < ncopies; n++)
/* Special implementation of the SPREAD intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
spread_generic.c written by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
ncopies = pncopies;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t ub, stride;
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (rs * sizeof(GFC_INTEGER_2));
+ ret->base_addr = internal_malloc_size (rs * sizeof(GFC_INTEGER_2));
if (rs <= 0)
return;
}
}
sstride0 = sstride[0];
rstride0 = rstride[0];
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
while (sptr)
{
if (along > 1)
runtime_error ("dim outside of rank in spread()");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
- ret->data = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_2));
+ ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_2));
ret->offset = 0;
GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
}
runtime_error ("dim too large in spread()");
}
- dest = ret->data;
+ dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < ncopies; n++)
/* Special implementation of the SPREAD intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
spread_generic.c written by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
ncopies = pncopies;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t ub, stride;
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (rs * sizeof(GFC_INTEGER_4));
+ ret->base_addr = internal_malloc_size (rs * sizeof(GFC_INTEGER_4));
if (rs <= 0)
return;
}
}
sstride0 = sstride[0];
rstride0 = rstride[0];
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
while (sptr)
{
if (along > 1)
runtime_error ("dim outside of rank in spread()");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
- ret->data = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_4));
+ ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_4));
ret->offset = 0;
GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
}
runtime_error ("dim too large in spread()");
}
- dest = ret->data;
+ dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < ncopies; n++)
/* Special implementation of the SPREAD intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
spread_generic.c written by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
ncopies = pncopies;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t ub, stride;
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (rs * sizeof(GFC_INTEGER_8));
+ ret->base_addr = internal_malloc_size (rs * sizeof(GFC_INTEGER_8));
if (rs <= 0)
return;
}
}
sstride0 = sstride[0];
rstride0 = rstride[0];
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
while (sptr)
{
if (along > 1)
runtime_error ("dim outside of rank in spread()");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
- ret->data = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_8));
+ ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_8));
ret->offset = 0;
GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
}
runtime_error ("dim too large in spread()");
}
- dest = ret->data;
+ dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < ncopies; n++)
/* Special implementation of the SPREAD intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
spread_generic.c written by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
ncopies = pncopies;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t ub, stride;
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (rs * sizeof(GFC_REAL_10));
+ ret->base_addr = internal_malloc_size (rs * sizeof(GFC_REAL_10));
if (rs <= 0)
return;
}
}
sstride0 = sstride[0];
rstride0 = rstride[0];
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
while (sptr)
{
if (along > 1)
runtime_error ("dim outside of rank in spread()");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
- ret->data = internal_malloc_size (ncopies * sizeof (GFC_REAL_10));
+ ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_REAL_10));
ret->offset = 0;
GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
}
runtime_error ("dim too large in spread()");
}
- dest = ret->data;
+ dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < ncopies; n++)
/* Special implementation of the SPREAD intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
spread_generic.c written by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
ncopies = pncopies;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t ub, stride;
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (rs * sizeof(GFC_REAL_16));
+ ret->base_addr = internal_malloc_size (rs * sizeof(GFC_REAL_16));
if (rs <= 0)
return;
}
}
sstride0 = sstride[0];
rstride0 = rstride[0];
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
while (sptr)
{
if (along > 1)
runtime_error ("dim outside of rank in spread()");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
- ret->data = internal_malloc_size (ncopies * sizeof (GFC_REAL_16));
+ ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_REAL_16));
ret->offset = 0;
GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
}
runtime_error ("dim too large in spread()");
}
- dest = ret->data;
+ dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < ncopies; n++)
/* Special implementation of the SPREAD intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
spread_generic.c written by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
ncopies = pncopies;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t ub, stride;
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (rs * sizeof(GFC_REAL_4));
+ ret->base_addr = internal_malloc_size (rs * sizeof(GFC_REAL_4));
if (rs <= 0)
return;
}
}
sstride0 = sstride[0];
rstride0 = rstride[0];
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
while (sptr)
{
if (along > 1)
runtime_error ("dim outside of rank in spread()");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
- ret->data = internal_malloc_size (ncopies * sizeof (GFC_REAL_4));
+ ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_REAL_4));
ret->offset = 0;
GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
}
runtime_error ("dim too large in spread()");
}
- dest = ret->data;
+ dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < ncopies; n++)
/* Special implementation of the SPREAD intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
spread_generic.c written by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
ncopies = pncopies;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t ub, stride;
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (rs * sizeof(GFC_REAL_8));
+ ret->base_addr = internal_malloc_size (rs * sizeof(GFC_REAL_8));
if (rs <= 0)
return;
}
}
sstride0 = sstride[0];
rstride0 = rstride[0];
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
while (sptr)
{
if (along > 1)
runtime_error ("dim outside of rank in spread()");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
- ret->data = internal_malloc_size (ncopies * sizeof (GFC_REAL_8));
+ ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_REAL_8));
ret->offset = 0;
GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
}
runtime_error ("dim too large in spread()");
}
- dest = ret->data;
+ dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < ncopies; n++)
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_COMPLEX_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_COMPLEX_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_COMPLEX_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_COMPLEX_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
/* Implementation of the TRANSPOSE intrinsic
- Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Tobias Schlüter
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
assert (GFC_DESCRIPTOR_RANK (source) == 2);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
assert (GFC_DESCRIPTOR_RANK (ret) == 2);
assert (ret->dtype == source->dtype);
GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1,
GFC_DESCRIPTOR_EXTENT(source, 1));
- ret->data = internal_malloc_size (sizeof (GFC_COMPLEX_10) * size0 ((array_t *) ret));
+ ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_10) * size0 ((array_t *) ret));
ret->offset = 0;
} else if (unlikely (compile_options.bounds_check))
{
rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
for (y=0; y < ycount; y++)
{
/* Implementation of the TRANSPOSE intrinsic
- Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Tobias Schlüter
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
assert (GFC_DESCRIPTOR_RANK (source) == 2);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
assert (GFC_DESCRIPTOR_RANK (ret) == 2);
assert (ret->dtype == source->dtype);
GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1,
GFC_DESCRIPTOR_EXTENT(source, 1));
- ret->data = internal_malloc_size (sizeof (GFC_COMPLEX_16) * size0 ((array_t *) ret));
+ ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_16) * size0 ((array_t *) ret));
ret->offset = 0;
} else if (unlikely (compile_options.bounds_check))
{
rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
for (y=0; y < ycount; y++)
{
/* Implementation of the TRANSPOSE intrinsic
- Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Tobias Schlüter
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
assert (GFC_DESCRIPTOR_RANK (source) == 2);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
assert (GFC_DESCRIPTOR_RANK (ret) == 2);
assert (ret->dtype == source->dtype);
GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1,
GFC_DESCRIPTOR_EXTENT(source, 1));
- ret->data = internal_malloc_size (sizeof (GFC_COMPLEX_4) * size0 ((array_t *) ret));
+ ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_4) * size0 ((array_t *) ret));
ret->offset = 0;
} else if (unlikely (compile_options.bounds_check))
{
rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
for (y=0; y < ycount; y++)
{
/* Implementation of the TRANSPOSE intrinsic
- Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Tobias Schlüter
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
assert (GFC_DESCRIPTOR_RANK (source) == 2);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
assert (GFC_DESCRIPTOR_RANK (ret) == 2);
assert (ret->dtype == source->dtype);
GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1,
GFC_DESCRIPTOR_EXTENT(source, 1));
- ret->data = internal_malloc_size (sizeof (GFC_COMPLEX_8) * size0 ((array_t *) ret));
+ ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_8) * size0 ((array_t *) ret));
ret->offset = 0;
} else if (unlikely (compile_options.bounds_check))
{
rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
for (y=0; y < ycount; y++)
{
/* Implementation of the TRANSPOSE intrinsic
- Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Tobias Schlüter
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
assert (GFC_DESCRIPTOR_RANK (source) == 2);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
assert (GFC_DESCRIPTOR_RANK (ret) == 2);
assert (ret->dtype == source->dtype);
GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1,
GFC_DESCRIPTOR_EXTENT(source, 1));
- ret->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * size0 ((array_t *) ret));
+ ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * size0 ((array_t *) ret));
ret->offset = 0;
} else if (unlikely (compile_options.bounds_check))
{
rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
for (y=0; y < ycount; y++)
{
/* Implementation of the TRANSPOSE intrinsic
- Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Tobias Schlüter
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
assert (GFC_DESCRIPTOR_RANK (source) == 2);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
assert (GFC_DESCRIPTOR_RANK (ret) == 2);
assert (ret->dtype == source->dtype);
GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1,
GFC_DESCRIPTOR_EXTENT(source, 1));
- ret->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * size0 ((array_t *) ret));
+ ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * size0 ((array_t *) ret));
ret->offset = 0;
} else if (unlikely (compile_options.bounds_check))
{
rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
for (y=0; y < ycount; y++)
{
/* Implementation of the TRANSPOSE intrinsic
- Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Tobias Schlüter
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
assert (GFC_DESCRIPTOR_RANK (source) == 2);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
assert (GFC_DESCRIPTOR_RANK (ret) == 2);
assert (ret->dtype == source->dtype);
GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1,
GFC_DESCRIPTOR_EXTENT(source, 1));
- ret->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * size0 ((array_t *) ret));
+ ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * size0 ((array_t *) ret));
ret->offset = 0;
} else if (unlikely (compile_options.bounds_check))
{
rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
for (y=0; y < ycount; y++)
{
/* Implementation of the TRANSPOSE intrinsic
- Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Tobias Schlüter
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
assert (GFC_DESCRIPTOR_RANK (source) == 2);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
assert (GFC_DESCRIPTOR_RANK (ret) == 2);
assert (ret->dtype == source->dtype);
GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1,
GFC_DESCRIPTOR_EXTENT(source, 1));
- ret->data = internal_malloc_size (sizeof (GFC_REAL_10) * size0 ((array_t *) ret));
+ ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_10) * size0 ((array_t *) ret));
ret->offset = 0;
} else if (unlikely (compile_options.bounds_check))
{
rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
for (y=0; y < ycount; y++)
{
/* Implementation of the TRANSPOSE intrinsic
- Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Tobias Schlüter
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
assert (GFC_DESCRIPTOR_RANK (source) == 2);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
assert (GFC_DESCRIPTOR_RANK (ret) == 2);
assert (ret->dtype == source->dtype);
GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1,
GFC_DESCRIPTOR_EXTENT(source, 1));
- ret->data = internal_malloc_size (sizeof (GFC_REAL_16) * size0 ((array_t *) ret));
+ ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_16) * size0 ((array_t *) ret));
ret->offset = 0;
} else if (unlikely (compile_options.bounds_check))
{
rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
for (y=0; y < ycount; y++)
{
/* Implementation of the TRANSPOSE intrinsic
- Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Tobias Schlüter
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
assert (GFC_DESCRIPTOR_RANK (source) == 2);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
assert (GFC_DESCRIPTOR_RANK (ret) == 2);
assert (ret->dtype == source->dtype);
GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1,
GFC_DESCRIPTOR_EXTENT(source, 1));
- ret->data = internal_malloc_size (sizeof (GFC_REAL_4) * size0 ((array_t *) ret));
+ ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_4) * size0 ((array_t *) ret));
ret->offset = 0;
} else if (unlikely (compile_options.bounds_check))
{
rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
for (y=0; y < ycount; y++)
{
/* Implementation of the TRANSPOSE intrinsic
- Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Tobias Schlüter
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
assert (GFC_DESCRIPTOR_RANK (source) == 2);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
assert (GFC_DESCRIPTOR_RANK (ret) == 2);
assert (ret->dtype == source->dtype);
GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1,
GFC_DESCRIPTOR_EXTENT(source, 1));
- ret->data = internal_malloc_size (sizeof (GFC_REAL_8) * size0 ((array_t *) ret));
+ ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_8) * size0 ((array_t *) ret));
ret->offset = 0;
} else if (unlikely (compile_options.bounds_check))
{
rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
for (y=0; y < ycount; y++)
{
/* Specific implementation of the UNPACK intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
unpack_generic.c by Paul Brook <paul@nowt.org>.
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_COMPLEX_10));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_10));
}
else
{
vstride0 = 1;
rstride0 = rstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_COMPLEX_10));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_10));
}
else
{
rstride0 = rstride[0];
fstride0 = fstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- fptr = field->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ fptr = field->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
/* Specific implementation of the UNPACK intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
unpack_generic.c by Paul Brook <paul@nowt.org>.
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_COMPLEX_16));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_16));
}
else
{
vstride0 = 1;
rstride0 = rstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_COMPLEX_16));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_16));
}
else
{
rstride0 = rstride[0];
fstride0 = fstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- fptr = field->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ fptr = field->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
/* Specific implementation of the UNPACK intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
unpack_generic.c by Paul Brook <paul@nowt.org>.
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_COMPLEX_4));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_4));
}
else
{
vstride0 = 1;
rstride0 = rstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_COMPLEX_4));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_4));
}
else
{
rstride0 = rstride[0];
fstride0 = fstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- fptr = field->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ fptr = field->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
/* Specific implementation of the UNPACK intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
unpack_generic.c by Paul Brook <paul@nowt.org>.
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_COMPLEX_8));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_8));
}
else
{
vstride0 = 1;
rstride0 = rstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_COMPLEX_8));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_8));
}
else
{
rstride0 = rstride[0];
fstride0 = fstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- fptr = field->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ fptr = field->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
/* Specific implementation of the UNPACK intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
unpack_generic.c by Paul Brook <paul@nowt.org>.
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_1));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_1));
}
else
{
vstride0 = 1;
rstride0 = rstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_1));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_1));
}
else
{
rstride0 = rstride[0];
fstride0 = fstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- fptr = field->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ fptr = field->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
/* Specific implementation of the UNPACK intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
unpack_generic.c by Paul Brook <paul@nowt.org>.
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_16));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_16));
}
else
{
vstride0 = 1;
rstride0 = rstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_16));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_16));
}
else
{
rstride0 = rstride[0];
fstride0 = fstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- fptr = field->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ fptr = field->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
/* Specific implementation of the UNPACK intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
unpack_generic.c by Paul Brook <paul@nowt.org>.
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_2));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_2));
}
else
{
vstride0 = 1;
rstride0 = rstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_2));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_2));
}
else
{
rstride0 = rstride[0];
fstride0 = fstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- fptr = field->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ fptr = field->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
/* Specific implementation of the UNPACK intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
unpack_generic.c by Paul Brook <paul@nowt.org>.
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_4));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_4));
}
else
{
vstride0 = 1;
rstride0 = rstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_4));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_4));
}
else
{
rstride0 = rstride[0];
fstride0 = fstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- fptr = field->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ fptr = field->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
/* Specific implementation of the UNPACK intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
unpack_generic.c by Paul Brook <paul@nowt.org>.
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_8));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_8));
}
else
{
vstride0 = 1;
rstride0 = rstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_8));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_8));
}
else
{
rstride0 = rstride[0];
fstride0 = fstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- fptr = field->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ fptr = field->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
/* Specific implementation of the UNPACK intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
unpack_generic.c by Paul Brook <paul@nowt.org>.
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_REAL_10));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_10));
}
else
{
vstride0 = 1;
rstride0 = rstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_REAL_10));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_10));
}
else
{
rstride0 = rstride[0];
fstride0 = fstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- fptr = field->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ fptr = field->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
/* Specific implementation of the UNPACK intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
unpack_generic.c by Paul Brook <paul@nowt.org>.
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_REAL_16));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_16));
}
else
{
vstride0 = 1;
rstride0 = rstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_REAL_16));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_16));
}
else
{
rstride0 = rstride[0];
fstride0 = fstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- fptr = field->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ fptr = field->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
/* Specific implementation of the UNPACK intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
unpack_generic.c by Paul Brook <paul@nowt.org>.
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_REAL_4));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_4));
}
else
{
vstride0 = 1;
rstride0 = rstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_REAL_4));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_4));
}
else
{
rstride0 = rstride[0];
fstride0 = fstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- fptr = field->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ fptr = field->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
/* Specific implementation of the UNPACK intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
unpack_generic.c by Paul Brook <paul@nowt.org>.
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_REAL_8));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_8));
}
else
{
vstride0 = 1;
rstride0 = rstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof (GFC_REAL_8));
+ ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_8));
}
else
{
rstride0 = rstride[0];
fstride0 = fstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- fptr = field->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ fptr = field->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
/* Generic implementation of the CSHIFT intrinsic
- Copyright 2003, 2005, 2006, 2007, 2010 Free Software Foundation, Inc.
+ Copyright 2003, 2005, 2006, 2007, 2010, 2012 Free Software Foundation, Inc.
Contributed by Feng Wang <wf_cs@yahoo.com>
This file is part of the GNU Fortran runtime library (libgfortran).
arraysize = size0 ((array_t *) array);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
int i;
}
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
}
else if (unlikely (compile_options.bounds_check))
{
break;
case sizeof (GFC_INTEGER_2):
- if (GFC_UNALIGNED_2(ret->data) || GFC_UNALIGNED_2(array->data))
+ if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(array->base_addr))
break;
else
{
}
case sizeof (GFC_INTEGER_4):
- if (GFC_UNALIGNED_4(ret->data) || GFC_UNALIGNED_4(array->data))
+ if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(array->base_addr))
break;
else
{
}
case sizeof (GFC_INTEGER_8):
- if (GFC_UNALIGNED_8(ret->data) || GFC_UNALIGNED_8(array->data))
+ if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(array->base_addr))
{
/* Let's try to use the complex routines. First, a sanity
check that the sizes match; this should be optimized to
if (sizeof(GFC_INTEGER_8) != sizeof(GFC_COMPLEX_4))
break;
- if (GFC_UNALIGNED_C4(ret->data) || GFC_UNALIGNED_C4(array->data))
+ if (GFC_UNALIGNED_C4(ret->base_addr)
+ || GFC_UNALIGNED_C4(array->base_addr))
break;
cshift0_c4 ((gfc_array_c4 *) ret, (gfc_array_c4 *) array, shift,
#ifdef HAVE_GFC_INTEGER_16
case sizeof (GFC_INTEGER_16):
- if (GFC_UNALIGNED_16(ret->data) || GFC_UNALIGNED_16(array->data))
+ if (GFC_UNALIGNED_16(ret->base_addr)
+ || GFC_UNALIGNED_16(array->base_addr))
{
/* Let's try to use the complex routines. First, a sanity
check that the sizes match; this should be optimized to
if (sizeof(GFC_INTEGER_16) != sizeof(GFC_COMPLEX_8))
break;
- if (GFC_UNALIGNED_C8(ret->data) || GFC_UNALIGNED_C8(array->data))
+ if (GFC_UNALIGNED_C8(ret->base_addr)
+ || GFC_UNALIGNED_C8(array->base_addr))
break;
cshift0_c8 ((gfc_array_c8 *) ret, (gfc_array_c8 *) array, shift,
#else
case sizeof (GFC_COMPLEX_8):
- if (GFC_UNALIGNED_C8(ret->data) || GFC_UNALIGNED_C8(array->data))
+ if (GFC_UNALIGNED_C8(ret->base_addr)
+ || GFC_UNALIGNED_C8(array->base_addr))
break;
else
{
dim = GFC_DESCRIPTOR_RANK (array);
rstride0 = rstride[0];
sstride0 = sstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
if (shift < 0)
/* Implementation of the DATE_AND_TIME intrinsic.
- Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011
+ Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011, 2012
Free Software Foundation, Inc.
Contributed by Steven Bosscher.
/* Cope with different type kinds. */
if (elt_size == 4)
{
- GFC_INTEGER_4 *vptr4 = __values->data;
+ GFC_INTEGER_4 *vptr4 = __values->base_addr;
for (i = 0; i < VALUES_SIZE; i++, vptr4 += delta)
*vptr4 = values[i];
}
else if (elt_size == 8)
{
- GFC_INTEGER_8 *vptr8 = (GFC_INTEGER_8 *)__values->data;
+ GFC_INTEGER_8 *vptr8 = (GFC_INTEGER_8 *)__values->base_addr;
for (i = 0; i < VALUES_SIZE; i++, vptr8 += delta)
{
/* Make the INTEGER*4 array for passing to date_and_time. */
gfc_array_i4 *avalues = internal_malloc_size (sizeof (gfc_array_i4));
- avalues->data = &values[0];
+ avalues->base_addr = &values[0];
GFC_DESCRIPTOR_DTYPE (avalues) = ((BT_REAL << GFC_DTYPE_TYPE_SHIFT)
& GFC_DTYPE_TYPE_MASK) +
(4 << GFC_DTYPE_SIZE_SHIFT);
if (delta == 0)
delta = 1;
- vptr = __values->data;
+ vptr = __values->base_addr;
for (i = 0; i < 3; i++, vptr += delta)
*vptr = x[i];
}
if (delta == 0)
delta = 1;
- vptr = __values->data;
+ vptr = __values->base_addr;
for (i = 0; i < 3; i++, vptr += delta)
*vptr = x[i];
}
if (delta == 0)
delta = 1;
- vptr = __values->data;
+ vptr = __values->base_addr;
for (i = 0; i < 3; i++, vptr += delta)
*vptr = x[i];
}
if (delta == 0)
delta = 1;
- vptr = __values->data;
+ vptr = __values->base_addr;
for (i = 0; i < 3; i++, vptr += delta)
*vptr = x[i];
}
if (delta == 0)
delta = 1;
- vptr = tarray->data;
+ vptr = tarray->base_addr;
for (i = 0; i < 9; i++, vptr += delta)
*vptr = x[i];
}
if (delta == 0)
delta = 1;
- vptr = tarray->data;
+ vptr = tarray->base_addr;
for (i = 0; i < 9; i++, vptr += delta)
*vptr = x[i];
}
if (delta == 0)
delta = 1;
- vptr = tarray->data;
+ vptr = tarray->base_addr;
for (i = 0; i < 9; i++, vptr += delta)
*vptr = x[i];
}
if (delta == 0)
delta = 1;
- vptr = tarray->data;
+ vptr = tarray->base_addr;
for (i = 0; i < 9; i++, vptr += delta)
*vptr = x[i];
}
/* Implementation of the dtime intrinsic.
- Copyright (C) 2004, 2005, 2006, 2007, 2009, 2011 Free Software
- Foundation, Inc.
+ Copyright (C) 2004, 2005, 2006, 2007, 2009, 2011, 2012
+ Free Software Foundation, Inc.
This file is part of the GNU Fortran runtime library (libgfortran).
tt = -1;
}
- tp = t->data;
+ tp = t->base_addr;
*tp = tu;
tp += GFC_DESCRIPTOR_STRIDE(t,0);
/* Generic implementation of the EOSHIFT intrinsic
- Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
arraysize = size0 ((array_t *) array);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
int i;
}
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
}
else if (unlikely (compile_options.bounds_check))
{
dim = GFC_DESCRIPTOR_RANK (array);
rstride0 = rstride[0];
sstride0 = sstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
if ((shift >= 0 ? shift : -shift) > len)
{
/* Generic implementation of the EOSHIFT intrinsic
- Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
arraysize = size0 ((array_t *) array);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
int i;
GFC_DIMENSION_SET(ret->dim[i], 0, ub, str);
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
}
}
rstride0 = rstride[0];
sstride0 = sstride[0];
bstride0 = bstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
if ((shift >= 0 ? shift : -shift ) > len)
{
}
if (bound)
- bptr = bound->data;
+ bptr = bound->base_addr;
else
bptr = NULL;
/* Implementation of the ETIME intrinsic.
- Copyright (C) 2004, 2005, 2006, 2007, 2009, 2011 Free Software
- Foundation, Inc.
+ Copyright (C) 2004, 2005, 2006, 2007, 2009, 2011, 2012
+ Free Software Foundation, Inc.
Contributed by Steven G. Kargl <kargls@comcast.net>.
This file is part of the GNU Fortran runtime library (libgfortran).
tt = (GFC_REAL_4)-1.0;
}
- tp = t->data;
+ tp = t->base_addr;
*tp = tu;
tp += GFC_DESCRIPTOR_STRIDE(t,0);
/* Implementation of the ISO_C_BINDING library helper functions.
- Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 2007, 2009, 2010, 2012 Free Software Foundation, Inc.
Contributed by Christopher Rickett.
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
f_ptr_out->offset = str;
shapeSize = 0;
- p = shape->data;
+ p = shape->base_addr;
size = GFC_DESCRIPTOR_SIZE(shape);
source_stride = GFC_DESCRIPTOR_STRIDE_BYTES(shape,0);
/* Generic implementation of the MOVE_ALLOC intrinsic
- Copyright (C) 2006, 2007, 2009, 2011 Free Software Foundation, Inc.
+ Copyright (C) 2006, 2007, 2009, 2011, 2012 Free Software Foundation, Inc.
Contributed by Paul Thomas
This file is part of the GNU Fortran runtime library (libgfortran).
{
int i;
- free (to->data);
+ free (to->base_addr);
for (i = 0; i < GFC_DESCRIPTOR_RANK (from); i++)
{
to->offset = from->offset;
to->dtype = from->dtype;
- to->data = from->data;
- from->data = NULL;
+ to->base_addr = from->base_addr;
+ from->base_addr = NULL;
}
extern void move_alloc_c (gfc_array_char *, GFC_INTEGER_4,
/* Generic implementation of the PACK intrinsic
- Copyright (C) 2002, 2004, 2005, 2006, 2007, 2009, 2010
+ Copyright (C) 2002, 2004, 2005, 2006, 2007, 2009, 2010, 2012
Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
- sptr = array->data;
- mptr = mask->data;
+ sptr = array->base_addr;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
if (mstride[0] == 0)
mstride[0] = mask_kind;
- if (ret->data == NULL || unlikely (compile_options.bounds_check))
+ if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
total = count_0 (mask);
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* Setup the array descriptor. */
GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (size * total);
+ ret->base_addr = internal_malloc_size (size * total);
if (total == 0)
return; /* In this case, nothing remains to be done. */
rstride0 = size;
sstride0 = sstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
+ rptr = ret->base_addr;
while (sptr && mptr)
{
if (vector)
{
n = GFC_DESCRIPTOR_EXTENT(vector,0);
- nelem = ((rptr - ret->data) / rstride0);
+ nelem = ((rptr - ret->base_addr) / rstride0);
if (n > nelem)
{
sstride0 = GFC_DESCRIPTOR_STRIDE_BYTES(vector,0);
if (sstride0 == 0)
sstride0 = size;
- sptr = vector->data + sstride0 * nelem;
+ sptr = vector->base_addr + sstride0 * nelem;
n -= nelem;
while (n--)
{
the unpack functions. */
case GFC_DTYPE_DERIVED_2:
- if (GFC_UNALIGNED_2(ret->data) || GFC_UNALIGNED_2(array->data)
- || (vector && GFC_UNALIGNED_2(vector->data)))
+ if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(array->base_addr)
+ || (vector && GFC_UNALIGNED_2(vector->base_addr)))
break;
else
{
}
case GFC_DTYPE_DERIVED_4:
- if (GFC_UNALIGNED_4(ret->data) || GFC_UNALIGNED_4(array->data)
- || (vector && GFC_UNALIGNED_4(vector->data)))
+ if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(array->base_addr)
+ || (vector && GFC_UNALIGNED_4(vector->base_addr)))
break;
else
{
}
case GFC_DTYPE_DERIVED_8:
- if (GFC_UNALIGNED_8(ret->data) || GFC_UNALIGNED_8(array->data)
- || (vector && GFC_UNALIGNED_8(vector->data)))
+ if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(array->base_addr)
+ || (vector && GFC_UNALIGNED_8(vector->base_addr)))
break;
else
{
#ifdef HAVE_GFC_INTEGER_16
case GFC_DTYPE_DERIVED_16:
- if (GFC_UNALIGNED_16(ret->data) || GFC_UNALIGNED_16(array->data)
- || (vector && GFC_UNALIGNED_16(vector->data)))
+ if (GFC_UNALIGNED_16(ret->base_addr) || GFC_UNALIGNED_16(array->base_addr)
+ || (vector && GFC_UNALIGNED_16(vector->base_addr)))
break;
else
{
sstride0 = sstride[0];
if (ssize != 0)
- sptr = array->data;
+ sptr = array->base_addr;
else
sptr = NULL;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* Allocate the memory for the result. */
ret->offset = 0;
- ret->data = internal_malloc_size (size * total);
+ ret->base_addr = internal_malloc_size (size * total);
if (total == 0)
return;
rstride0 = GFC_DESCRIPTOR_STRIDE_BYTES(ret,0);
if (rstride0 == 0)
rstride0 = size;
- rptr = ret->data;
+ rptr = ret->base_addr;
/* The remaining possibilities are now:
If MASK is .TRUE., we have to copy the source array into the
if (vector)
{
n = GFC_DESCRIPTOR_EXTENT(vector,0);
- nelem = ((rptr - ret->data) / rstride0);
+ nelem = ((rptr - ret->base_addr) / rstride0);
if (n > nelem)
{
sstride0 = GFC_DESCRIPTOR_STRIDE_BYTES(vector,0);
if (sstride0 == 0)
sstride0 = size;
- sptr = vector->data + sstride0 * nelem;
+ sptr = vector->base_addr + sstride0 * nelem;
n -= nelem;
while (n--)
{
/* Implementation of the RANDOM intrinsics
- Copyright 2002, 2004, 2005, 2006, 2007, 2009, 2010
+ Copyright 2002, 2004, 2005, 2006, 2007, 2009, 2010, 2012
Free Software Foundation, Inc.
Contributed by Lars Segerlund <seger@linuxmail.org>
and Steve Kargl.
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
GFC_UINTEGER_4 kiss;
int n;
- dest = x->data;
+ dest = x->base_addr;
dim = GFC_DESCRIPTOR_RANK (x);
GFC_UINTEGER_8 kiss;
int n;
- dest = x->data;
+ dest = x->base_addr;
dim = GFC_DESCRIPTOR_RANK (x);
GFC_UINTEGER_8 kiss;
int n;
- dest = x->data;
+ dest = x->base_addr;
dim = GFC_DESCRIPTOR_RANK (x);
GFC_UINTEGER_8 kiss1, kiss2;
int n;
- dest = x->data;
+ dest = x->base_addr;
dim = GFC_DESCRIPTOR_RANK (x);
/* We copy the seed given by the user. */
for (i = 0; i < kiss_size; i++)
memcpy (seed + i * sizeof(GFC_UINTEGER_4),
- &(put->data[(kiss_size - 1 - i) * GFC_DESCRIPTOR_STRIDE(put,0)]),
+ &(put->base_addr[(kiss_size - 1 - i) * GFC_DESCRIPTOR_STRIDE(put,0)]),
sizeof(GFC_UINTEGER_4));
/* We put it after scrambling the bytes, to paper around users who
/* Then copy it back to the user variable. */
for (i = 0; i < kiss_size; i++)
- memcpy (&(get->data[(kiss_size - 1 - i) * GFC_DESCRIPTOR_STRIDE(get,0)]),
+ memcpy (&(get->base_addr[(kiss_size - 1 - i) * GFC_DESCRIPTOR_STRIDE(get,0)]),
seed + i * sizeof(GFC_UINTEGER_4),
sizeof(GFC_UINTEGER_4));
}
/* This code now should do correct strides. */
for (i = 0; i < kiss_size / 2; i++)
- memcpy (&kiss_seed[2*i], &(put->data[i * GFC_DESCRIPTOR_STRIDE(put,0)]),
+ memcpy (&kiss_seed[2*i], &(put->base_addr[i * GFC_DESCRIPTOR_STRIDE(put,0)]),
sizeof (GFC_UINTEGER_8));
}
/* This code now should do correct strides. */
for (i = 0; i < kiss_size / 2; i++)
- memcpy (&(get->data[i * GFC_DESCRIPTOR_STRIDE(get,0)]), &kiss_seed[2*i],
+ memcpy (&(get->base_addr[i * GFC_DESCRIPTOR_STRIDE(get,0)]), &kiss_seed[2*i],
sizeof (GFC_UINTEGER_8));
}
/* Generic implementation of the RESHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
for (n = 0; n < rdim; n++)
{
- shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+ shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
{
shape_data[n] = 0;
}
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
index_type alloc_size;
else
alloc_size = rs * size;
- ret->data = internal_malloc_size (alloc_size);
+ ret->base_addr = internal_malloc_size (alloc_size);
ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
}
else
psize = 0;
}
- pptr = pad->data;
+ pptr = pad->base_addr;
}
else
{
for (n = 0; n < rdim; n++)
{
- v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
if (v < 0 || v >= rdim)
runtime_error("Value %ld out of range in ORDER argument"
for (n = 0; n < rdim; n++)
{
if (order)
- dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
dim = n;
rsize *= size;
ssize *= size;
psize *= size;
- reshape_packed (ret->data, rsize, source->data, ssize,
- pad ? pad->data : NULL, psize);
+ reshape_packed (ret->base_addr, rsize, source->base_addr, ssize,
+ pad ? pad->base_addr : NULL, psize);
return;
}
- rptr = ret->data;
- src = sptr = source->data;
+ rptr = ret->base_addr;
+ src = sptr = source->base_addr;
rstride0 = rstride[0] * size;
sstride0 = sstride[0] * size;
/* Generic implementation of the SPREAD intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2010, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
ncopies = *pncopies;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
GFC_DIMENSION_SET(ret->dim[n], 0, ub, stride);
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * size);
+ ret->base_addr = internal_malloc_size (rs * size);
if (rs <= 0)
return;
}
sstride0 = sstride[0];
rstride0 = rstride[0];
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
while (sptr)
{
if (*along > 1)
runtime_error ("dim outside of rank in spread()");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
- ret->data = internal_malloc_size (ncopies * size);
+ ret->base_addr = internal_malloc_size (ncopies * size);
ret->offset = 0;
GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
}
for (n = 0; n < ncopies; n++)
{
- dest = (char*)(ret->data + n * GFC_DESCRIPTOR_STRIDE_BYTES(ret,0));
+ dest = (char*)(ret->base_addr + n * GFC_DESCRIPTOR_STRIDE_BYTES(ret,0));
memcpy (dest , source, size);
}
}
#endif
case GFC_DTYPE_DERIVED_2:
- if (GFC_UNALIGNED_2(ret->data) || GFC_UNALIGNED_2(source->data))
+ if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(source->base_addr))
break;
else
{
}
case GFC_DTYPE_DERIVED_4:
- if (GFC_UNALIGNED_4(ret->data) || GFC_UNALIGNED_4(source->data))
+ if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(source->base_addr))
break;
else
{
}
case GFC_DTYPE_DERIVED_8:
- if (GFC_UNALIGNED_8(ret->data) || GFC_UNALIGNED_8(source->data))
+ if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(source->base_addr))
break;
else
{
#ifdef HAVE_GFC_INTEGER_16
case GFC_DTYPE_DERIVED_16:
- if (GFC_UNALIGNED_16(ret->data) || GFC_UNALIGNED_16(source->data))
+ if (GFC_UNALIGNED_16(ret->base_addr)
+ || GFC_UNALIGNED_16(source->base_addr))
break;
else
{
#endif
case GFC_DTYPE_DERIVED_2:
- if (GFC_UNALIGNED_2(ret->data) || GFC_UNALIGNED_2(source))
+ if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(source))
break;
else
{
}
case GFC_DTYPE_DERIVED_4:
- if (GFC_UNALIGNED_4(ret->data) || GFC_UNALIGNED_4(source))
+ if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(source))
break;
else
{
}
case GFC_DTYPE_DERIVED_8:
- if (GFC_UNALIGNED_8(ret->data) || GFC_UNALIGNED_8(source))
+ if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(source))
break;
else
{
}
#ifdef HAVE_GFC_INTEGER_16
case GFC_DTYPE_DERIVED_16:
- if (GFC_UNALIGNED_16(ret->data) || GFC_UNALIGNED_16(source))
+ if (GFC_UNALIGNED_16(ret->base_addr) || GFC_UNALIGNED_16(source))
break;
else
{
/* Implementation of the STAT and FSTAT intrinsics.
- Copyright (C) 2004, 2005, 2006, 2007, 2009, 2011
+ Copyright (C) 2004, 2005, 2006, 2007, 2009, 2011, 2012
Free Software Foundation, Inc.
Contributed by Steven G. Kargl <kargls@comcast.net>.
index_type stride = GFC_DESCRIPTOR_STRIDE(sarray,0);
/* Device ID */
- sarray->data[0 * stride] = sb.st_dev;
+ sarray->base_addr[0 * stride] = sb.st_dev;
/* Inode number */
- sarray->data[1 * stride] = sb.st_ino;
+ sarray->base_addr[1 * stride] = sb.st_ino;
/* File mode */
- sarray->data[2 * stride] = sb.st_mode;
+ sarray->base_addr[2 * stride] = sb.st_mode;
/* Number of (hard) links */
- sarray->data[3 * stride] = sb.st_nlink;
+ sarray->base_addr[3 * stride] = sb.st_nlink;
/* Owner's uid */
- sarray->data[4 * stride] = sb.st_uid;
+ sarray->base_addr[4 * stride] = sb.st_uid;
/* Owner's gid */
- sarray->data[5 * stride] = sb.st_gid;
+ sarray->base_addr[5 * stride] = sb.st_gid;
/* ID of device containing directory entry for file (0 if not available) */
#if HAVE_STRUCT_STAT_ST_RDEV
- sarray->data[6 * stride] = sb.st_rdev;
+ sarray->base_addr[6 * stride] = sb.st_rdev;
#else
- sarray->data[6 * stride] = 0;
+ sarray->base_addr[6 * stride] = 0;
#endif
/* File size (bytes) */
- sarray->data[7 * stride] = sb.st_size;
+ sarray->base_addr[7 * stride] = sb.st_size;
/* Last access time */
- sarray->data[8 * stride] = sb.st_atime;
+ sarray->base_addr[8 * stride] = sb.st_atime;
/* Last modification time */
- sarray->data[9 * stride] = sb.st_mtime;
+ sarray->base_addr[9 * stride] = sb.st_mtime;
/* Last file status change time */
- sarray->data[10 * stride] = sb.st_ctime;
+ sarray->base_addr[10 * stride] = sb.st_ctime;
/* Preferred I/O block size (-1 if not available) */
#if HAVE_STRUCT_STAT_ST_BLKSIZE
- sarray->data[11 * stride] = sb.st_blksize;
+ sarray->base_addr[11 * stride] = sb.st_blksize;
#else
- sarray->data[11 * stride] = -1;
+ sarray->base_addr[11 * stride] = -1;
#endif
/* Number of blocks allocated (-1 if not available) */
#if HAVE_STRUCT_STAT_ST_BLOCKS
- sarray->data[12 * stride] = sb.st_blocks;
+ sarray->base_addr[12 * stride] = sb.st_blocks;
#else
- sarray->data[12 * stride] = -1;
+ sarray->base_addr[12 * stride] = -1;
#endif
}
index_type stride = GFC_DESCRIPTOR_STRIDE(sarray,0);
/* Device ID */
- sarray->data[0] = sb.st_dev;
+ sarray->base_addr[0] = sb.st_dev;
/* Inode number */
- sarray->data[stride] = sb.st_ino;
+ sarray->base_addr[stride] = sb.st_ino;
/* File mode */
- sarray->data[2 * stride] = sb.st_mode;
+ sarray->base_addr[2 * stride] = sb.st_mode;
/* Number of (hard) links */
- sarray->data[3 * stride] = sb.st_nlink;
+ sarray->base_addr[3 * stride] = sb.st_nlink;
/* Owner's uid */
- sarray->data[4 * stride] = sb.st_uid;
+ sarray->base_addr[4 * stride] = sb.st_uid;
/* Owner's gid */
- sarray->data[5 * stride] = sb.st_gid;
+ sarray->base_addr[5 * stride] = sb.st_gid;
/* ID of device containing directory entry for file (0 if not available) */
#if HAVE_STRUCT_STAT_ST_RDEV
- sarray->data[6 * stride] = sb.st_rdev;
+ sarray->base_addr[6 * stride] = sb.st_rdev;
#else
- sarray->data[6 * stride] = 0;
+ sarray->base_addr[6 * stride] = 0;
#endif
/* File size (bytes) */
- sarray->data[7 * stride] = sb.st_size;
+ sarray->base_addr[7 * stride] = sb.st_size;
/* Last access time */
- sarray->data[8 * stride] = sb.st_atime;
+ sarray->base_addr[8 * stride] = sb.st_atime;
/* Last modification time */
- sarray->data[9 * stride] = sb.st_mtime;
+ sarray->base_addr[9 * stride] = sb.st_mtime;
/* Last file status change time */
- sarray->data[10 * stride] = sb.st_ctime;
+ sarray->base_addr[10 * stride] = sb.st_ctime;
/* Preferred I/O block size (-1 if not available) */
#if HAVE_STRUCT_STAT_ST_BLKSIZE
- sarray->data[11 * stride] = sb.st_blksize;
+ sarray->base_addr[11 * stride] = sb.st_blksize;
#else
- sarray->data[11 * stride] = -1;
+ sarray->base_addr[11 * stride] = -1;
#endif
/* Number of blocks allocated (-1 if not available) */
#if HAVE_STRUCT_STAT_ST_BLOCKS
- sarray->data[12 * stride] = sb.st_blocks;
+ sarray->base_addr[12 * stride] = sb.st_blocks;
#else
- sarray->data[12 * stride] = -1;
+ sarray->base_addr[12 * stride] = -1;
#endif
}
index_type stride = GFC_DESCRIPTOR_STRIDE(sarray,0);
/* Device ID */
- sarray->data[0 * stride] = sb.st_dev;
+ sarray->base_addr[0 * stride] = sb.st_dev;
/* Inode number */
- sarray->data[1 * stride] = sb.st_ino;
+ sarray->base_addr[1 * stride] = sb.st_ino;
/* File mode */
- sarray->data[2 * stride] = sb.st_mode;
+ sarray->base_addr[2 * stride] = sb.st_mode;
/* Number of (hard) links */
- sarray->data[3 * stride] = sb.st_nlink;
+ sarray->base_addr[3 * stride] = sb.st_nlink;
/* Owner's uid */
- sarray->data[4 * stride] = sb.st_uid;
+ sarray->base_addr[4 * stride] = sb.st_uid;
/* Owner's gid */
- sarray->data[5 * stride] = sb.st_gid;
+ sarray->base_addr[5 * stride] = sb.st_gid;
/* ID of device containing directory entry for file (0 if not available) */
#if HAVE_STRUCT_STAT_ST_RDEV
- sarray->data[6 * stride] = sb.st_rdev;
+ sarray->base_addr[6 * stride] = sb.st_rdev;
#else
- sarray->data[6 * stride] = 0;
+ sarray->base_addr[6 * stride] = 0;
#endif
/* File size (bytes) */
- sarray->data[7 * stride] = sb.st_size;
+ sarray->base_addr[7 * stride] = sb.st_size;
/* Last access time */
- sarray->data[8 * stride] = sb.st_atime;
+ sarray->base_addr[8 * stride] = sb.st_atime;
/* Last modification time */
- sarray->data[9 * stride] = sb.st_mtime;
+ sarray->base_addr[9 * stride] = sb.st_mtime;
/* Last file status change time */
- sarray->data[10 * stride] = sb.st_ctime;
+ sarray->base_addr[10 * stride] = sb.st_ctime;
/* Preferred I/O block size (-1 if not available) */
#if HAVE_STRUCT_STAT_ST_BLKSIZE
- sarray->data[11 * stride] = sb.st_blksize;
+ sarray->base_addr[11 * stride] = sb.st_blksize;
#else
- sarray->data[11 * stride] = -1;
+ sarray->base_addr[11 * stride] = -1;
#endif
/* Number of blocks allocated (-1 if not available) */
#if HAVE_STRUCT_STAT_ST_BLOCKS
- sarray->data[12 * stride] = sb.st_blocks;
+ sarray->base_addr[12 * stride] = sb.st_blocks;
#else
- sarray->data[12 * stride] = -1;
+ sarray->base_addr[12 * stride] = -1;
#endif
}
index_type stride = GFC_DESCRIPTOR_STRIDE(sarray,0);
/* Device ID */
- sarray->data[0] = sb.st_dev;
+ sarray->base_addr[0] = sb.st_dev;
/* Inode number */
- sarray->data[stride] = sb.st_ino;
+ sarray->base_addr[stride] = sb.st_ino;
/* File mode */
- sarray->data[2 * stride] = sb.st_mode;
+ sarray->base_addr[2 * stride] = sb.st_mode;
/* Number of (hard) links */
- sarray->data[3 * stride] = sb.st_nlink;
+ sarray->base_addr[3 * stride] = sb.st_nlink;
/* Owner's uid */
- sarray->data[4 * stride] = sb.st_uid;
+ sarray->base_addr[4 * stride] = sb.st_uid;
/* Owner's gid */
- sarray->data[5 * stride] = sb.st_gid;
+ sarray->base_addr[5 * stride] = sb.st_gid;
/* ID of device containing directory entry for file (0 if not available) */
#if HAVE_STRUCT_STAT_ST_RDEV
- sarray->data[6 * stride] = sb.st_rdev;
+ sarray->base_addr[6 * stride] = sb.st_rdev;
#else
- sarray->data[6 * stride] = 0;
+ sarray->base_addr[6 * stride] = 0;
#endif
/* File size (bytes) */
- sarray->data[7 * stride] = sb.st_size;
+ sarray->base_addr[7 * stride] = sb.st_size;
/* Last access time */
- sarray->data[8 * stride] = sb.st_atime;
+ sarray->base_addr[8 * stride] = sb.st_atime;
/* Last modification time */
- sarray->data[9 * stride] = sb.st_mtime;
+ sarray->base_addr[9 * stride] = sb.st_mtime;
/* Last file status change time */
- sarray->data[10 * stride] = sb.st_ctime;
+ sarray->base_addr[10 * stride] = sb.st_ctime;
/* Preferred I/O block size (-1 if not available) */
#if HAVE_STRUCT_STAT_ST_BLKSIZE
- sarray->data[11 * stride] = sb.st_blksize;
+ sarray->base_addr[11 * stride] = sb.st_blksize;
#else
- sarray->data[11 * stride] = -1;
+ sarray->base_addr[11 * stride] = -1;
#endif
/* Number of blocks allocated (-1 if not available) */
#if HAVE_STRUCT_STAT_ST_BLOCKS
- sarray->data[12 * stride] = sb.st_blocks;
+ sarray->base_addr[12 * stride] = sb.st_blocks;
#else
- sarray->data[12 * stride] = -1;
+ sarray->base_addr[12 * stride] = -1;
#endif
}
/* Implementation of the TRANSPOSE intrinsic
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Tobias Schlüter
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
size = GFC_DESCRIPTOR_SIZE(ret);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
assert (ret->dtype == source->dtype);
GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1,
GFC_DESCRIPTOR_EXTENT(source, 1));
- ret->data = internal_malloc_size (size * size0 ((array_t*)ret));
+ ret->base_addr = internal_malloc_size (size * size0 ((array_t*)ret));
ret->offset = 0;
}
else if (unlikely (compile_options.bounds_check))
rxstride = GFC_DESCRIPTOR_STRIDE_BYTES(ret,0);
rystride = GFC_DESCRIPTOR_STRIDE_BYTES(ret,1);
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
for (y = 0; y < ycount; y++)
{
/* Generic implementation of the UNPACK intrinsic
- Copyright 2002, 2003, 2004, 2005, 2007, 2009, 2010
+ Copyright 2002, 2003, 2004, 2005, 2007, 2009, 2010, 2012
Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
bounds_equal_extents ((array_t *) field, (array_t *) mask,
"FIELD", "UNPACK");
- if (ret->data != NULL)
+ if (ret->base_addr != NULL)
bounds_equal_extents ((array_t *) ret, (array_t *) mask,
"return value", "UNPACK");
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * size);
+ ret->base_addr = internal_malloc_size (rs * size);
}
else
{
rstride0 = rstride[0];
fstride0 = fstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- fptr = field->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ fptr = field->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
#endif
case GFC_DTYPE_DERIVED_2:
- if (GFC_UNALIGNED_2(ret->data) || GFC_UNALIGNED_2(vector->data)
- || GFC_UNALIGNED_2(field->data))
+ if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(vector->base_addr)
+ || GFC_UNALIGNED_2(field->base_addr))
break;
else
{
}
case GFC_DTYPE_DERIVED_4:
- if (GFC_UNALIGNED_4(ret->data) || GFC_UNALIGNED_4(vector->data)
- || GFC_UNALIGNED_4(field->data))
+ if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(vector->base_addr)
+ || GFC_UNALIGNED_4(field->base_addr))
break;
else
{
}
case GFC_DTYPE_DERIVED_8:
- if (GFC_UNALIGNED_8(ret->data) || GFC_UNALIGNED_8(vector->data)
- || GFC_UNALIGNED_8(field->data))
+ if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(vector->base_addr)
+ || GFC_UNALIGNED_8(field->base_addr))
break;
else
{
#ifdef HAVE_GFC_INTEGER_16
case GFC_DTYPE_DERIVED_16:
- if (GFC_UNALIGNED_16(ret->data) || GFC_UNALIGNED_16(vector->data)
- || GFC_UNALIGNED_16(field->data))
+ if (GFC_UNALIGNED_16(ret->base_addr)
+ || GFC_UNALIGNED_16(vector->base_addr)
+ || GFC_UNALIGNED_16(field->base_addr))
break;
else
{
#endif
case GFC_DTYPE_DERIVED_2:
- if (GFC_UNALIGNED_2(ret->data) || GFC_UNALIGNED_2(vector->data)
+ if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(vector->base_addr)
|| GFC_UNALIGNED_2(field))
break;
else
}
case GFC_DTYPE_DERIVED_4:
- if (GFC_UNALIGNED_4(ret->data) || GFC_UNALIGNED_4(vector->data)
+ if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(vector->base_addr)
|| GFC_UNALIGNED_4(field))
break;
else
}
case GFC_DTYPE_DERIVED_8:
- if (GFC_UNALIGNED_8(ret->data) || GFC_UNALIGNED_8(vector->data)
+ if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(vector->base_addr)
|| GFC_UNALIGNED_8(field))
break;
else
#ifdef HAVE_GFC_INTEGER_16
case GFC_DTYPE_DERIVED_16:
- if (GFC_UNALIGNED_16(ret->data) || GFC_UNALIGNED_16(vector->data)
+ if (GFC_UNALIGNED_16(ret->base_addr)
+ || GFC_UNALIGNED_16(vector->base_addr)
|| GFC_UNALIGNED_16(field))
break;
else
memset (&tmp, 0, sizeof (tmp));
tmp.dtype = 0;
- tmp.data = field;
+ tmp.base_addr = field;
unpack_internal (ret, vector, mask, &tmp, GFC_DESCRIPTOR_SIZE (vector));
}
memset (&tmp, 0, sizeof (tmp));
tmp.dtype = 0;
- tmp.data = field;
+ tmp.base_addr = field;
unpack_internal (ret, vector, mask, &tmp, vector_length);
}
memset (&tmp, 0, sizeof (tmp));
tmp.dtype = 0;
- tmp.data = field;
+ tmp.base_addr = field;
unpack_internal (ret, vector, mask, &tmp,
vector_length * sizeof (gfc_char4_t));
}
/* Common declarations for all of libgfortran.
Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
- 2011
+ 2011, 2012
Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>, and
Andy Vaught <andy@xena.eas.asu.edu>
typedef struct descriptor_dimension
{
index_type _stride;
- index_type _lbound;
+ index_type lower_bound;
index_type _ubound;
}
#define GFC_ARRAY_DESCRIPTOR(r, type) \
struct {\
- type *data;\
+ type *base_addr;\
size_t offset;\
index_type dtype;\
descriptor_dimension dim[r];\
#define GFC_DESCRIPTOR_TYPE(desc) (((desc)->dtype & GFC_DTYPE_TYPE_MASK) \
>> GFC_DTYPE_TYPE_SHIFT)
#define GFC_DESCRIPTOR_SIZE(desc) ((desc)->dtype >> GFC_DTYPE_SIZE_SHIFT)
-#define GFC_DESCRIPTOR_DATA(desc) ((desc)->data)
+#define GFC_DESCRIPTOR_DATA(desc) ((desc)->base_addr)
#define GFC_DESCRIPTOR_DTYPE(desc) ((desc)->dtype)
-#define GFC_DIMENSION_LBOUND(dim) ((dim)._lbound)
+#define GFC_DIMENSION_LBOUND(dim) ((dim).lower_bound)
#define GFC_DIMENSION_UBOUND(dim) ((dim)._ubound)
#define GFC_DIMENSION_STRIDE(dim) ((dim)._stride)
-#define GFC_DIMENSION_EXTENT(dim) ((dim)._ubound + 1 - (dim)._lbound)
+#define GFC_DIMENSION_EXTENT(dim) ((dim)._ubound + 1 - (dim).lower_bound)
#define GFC_DIMENSION_SET(dim,lb,ub,str) \
do \
{ \
- (dim)._lbound = lb; \
+ (dim).lower_bound = lb; \
(dim)._ubound = ub; \
(dim)._stride = str; \
} while (0)
-#define GFC_DESCRIPTOR_LBOUND(desc,i) ((desc)->dim[i]._lbound)
+#define GFC_DESCRIPTOR_LBOUND(desc,i) ((desc)->dim[i].lower_bound)
#define GFC_DESCRIPTOR_UBOUND(desc,i) ((desc)->dim[i]._ubound)
#define GFC_DESCRIPTOR_EXTENT(desc,i) ((desc)->dim[i]._ubound + 1 \
- - (desc)->dim[i]._lbound)
+ - (desc)->dim[i].lower_bound)
#define GFC_DESCRIPTOR_EXTENT_BYTES(desc,i) \
(GFC_DESCRIPTOR_EXTENT(desc,i) * GFC_DESCRIPTOR_SIZE(desc))
`/* Implementation of the BESSEL_JN and BESSEL_YN transformational
function using a recurrence algorithm.
- Copyright 2010 Free Software Foundation, Inc.
+ Copyright 2010, 2012 Free Software Foundation, Inc.
Contributed by Tobias Burnus <burnus@net-b.de>
This file is part of the GNU Fortran runtime library (libgfortran).
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t size = n2 < n1 ? 0 : n2-n1+1;
GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
- ret->data = internal_malloc_size (sizeof ('rtype_name`) * size);
+ ret->base_addr = internal_malloc_size (sizeof ('rtype_name`) * size);
ret->offset = 0;
}
if (unlikely (x == 0))
{
- ret->data[0] = 1;
+ ret->base_addr[0] = 1;
for (i = 1; i <= n2-n1; i++)
- ret->data[i*stride] = 0;
+ ret->base_addr[i*stride] = 0;
return;
}
- ret->data = ret->data;
last1 = MATHFUNC(jn) (n2, x);
- ret->data[(n2-n1)*stride] = last1;
+ ret->base_addr[(n2-n1)*stride] = last1;
if (n1 == n2)
return;
last2 = MATHFUNC(jn) (n2 - 1, x);
- ret->data[(n2-n1-1)*stride] = last2;
+ ret->base_addr[(n2-n1-1)*stride] = last2;
if (n1 + 1 == n2)
return;
for (i = n2-n1-2; i >= 0; i--)
{
- ret->data[i*stride] = x2rev * (i+1+n1) * last2 - last1;
+ ret->base_addr[i*stride] = x2rev * (i+1+n1) * last2 - last1;
last1 = last2;
- last2 = ret->data[i*stride];
+ last2 = ret->base_addr[i*stride];
}
}
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t size = n2 < n1 ? 0 : n2-n1+1;
GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
- ret->data = internal_malloc_size (sizeof ('rtype_name`) * size);
+ ret->base_addr = internal_malloc_size (sizeof ('rtype_name`) * size);
ret->offset = 0;
}
{
for (i = 0; i <= n2-n1; i++)
#if defined('rtype_name`_INFINITY)
- ret->data[i*stride] = -'rtype_name`_INFINITY;
+ ret->base_addr[i*stride] = -'rtype_name`_INFINITY;
#else
- ret->data[i*stride] = -'rtype_name`_HUGE;
+ ret->base_addr[i*stride] = -'rtype_name`_HUGE;
#endif
return;
}
- ret->data = ret->data;
+ ret->base_addr = ret->base_addr;
last1 = MATHFUNC(yn) (n1, x);
- ret->data[0] = last1;
+ ret->base_addr[0] = last1;
if (n1 == n2)
return;
last2 = MATHFUNC(yn) (n1 + 1, x);
- ret->data[1*stride] = last2;
+ ret->base_addr[1*stride] = last2;
if (n1 + 1 == n2)
return;
#if defined('rtype_name`_INFINITY)
if (unlikely (last2 == -'rtype_name`_INFINITY))
{
- ret->data[i*stride] = -'rtype_name`_INFINITY;
+ ret->base_addr[i*stride] = -'rtype_name`_INFINITY;
}
else
#endif
{
- ret->data[i*stride] = x2rev * (i-1+n1) * last2 - last1;
+ ret->base_addr[i*stride] = x2rev * (i-1+n1) * last2 - last1;
last1 = last2;
- last2 = ret->data[i*stride];
+ last2 = ret->base_addr[i*stride];
}
}
}
`/* Helper function for cshift functions.
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
rstride0 = rstride[0];
sstride0 = sstride[0];
- rptr = ret->data;
- sptr = array->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
if (shift < 0)
`/* Implementation of the CSHIFT intrinsic
- Copyright 2003, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Feng Wang <wf_cs@yahoo.com>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
arraysize = size0 ((array_t *)array);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
int i;
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
ret->offset = 0;
ret->dtype = array->dtype;
for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
rstride0 = rstride[0];
sstride0 = sstride[0];
hstride0 = hstride[0];
- rptr = ret->data;
- sptr = array->data;
- hptr = h->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
+ hptr = h->base_addr;
while (rptr)
{
`/* Implementation of the EOSHIFT intrinsic
- Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
count[0] = 0;
arraysize = size0 ((array_t *) array);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
int i;
}
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
}
else if (unlikely (compile_options.bounds_check))
rstride0 = rstride[0];
sstride0 = sstride[0];
hstride0 = hstride[0];
- rptr = ret->data;
- sptr = array->data;
- hptr = h->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
+ hptr = h->base_addr;
while (rptr)
{
`/* Implementation of the EOSHIFT intrinsic
- Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
else
which = 0;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
int i;
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
ret->offset = 0;
ret->dtype = array->dtype;
for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
}
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (size * arraysize);
+ ret->base_addr = internal_malloc_size (size * arraysize);
}
else if (unlikely (compile_options.bounds_check))
sstride0 = sstride[0];
hstride0 = hstride[0];
bstride0 = bstride[0];
- rptr = ret->data;
- sptr = array->data;
- hptr = h->data;
+ rptr = ret->base_addr;
+ sptr = array->base_addr;
+ hptr = h->base_addr;
if (bound)
- bptr = bound->data;
+ bptr = bound->base_addr;
else
bptr = NULL;
dnl Support macro file for intrinsic functions.
dnl Contains the generic sections of the array functions.
-dnl This file is part of the GNU Fortran 95 Runtime Library (libgfortran)
+dnl This file is part of the GNU Fortran Runtime Library (libgfortran)
dnl Distributed under the GNU GPL with exception. See COPYING for details.
define(START_FOREACH_FUNCTION,
`
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (rtype_name) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (rtype_name) * rank);
}
else
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (rtype_name) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (rtype_name) * rank);
}
else
{
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
- mbase = mask->data;
+ mbase = mask->base_addr;
if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
runtime_error ("Funny sized logical array");
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n < rank; n++)
{
sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
}
}
- base = array->data;
+ base = array->base_addr;
/* Initialize the return value. */
for (n = 0; n < rank; n++)
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
retarray->offset = 0;
- retarray->data = internal_malloc_size (sizeof (rtype_name) * rank);
+ retarray->base_addr = internal_malloc_size (sizeof (rtype_name) * rank);
}
else if (unlikely (compile_options.bounds_check))
{
}
dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
- dest = retarray->data;
+ dest = retarray->base_addr;
for (n = 0; n<rank; n++)
dest[n * dstride] = $1 ;
}')dnl
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
alloc_size = sizeof (rtype_name) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
* extent[rank-1];
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
if (alloc_size == 0)
{
/* Make sure we have a zero-sized array. */
return;
}
- base = array->data;
- dest = retarray->data;
+ base = array->base_addr;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
if (len <= 0)
return;
- mbase = mask->data;
+ mbase = mask->base_addr;
mask_kind = GFC_DESCRIPTOR_SIZE (mask);
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
return;
}
- dest = retarray->data;
- base = array->data;
+ dest = retarray->base_addr;
+ base = array->base_addr;
while (base)
{
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
}
- dest = retarray->data;
+ dest = retarray->base_addr;
while(1)
{
dnl Support macro file for intrinsic functions.
dnl Contains the generic sections of the array functions.
-dnl This file is part of the GNU Fortran 95 Runtime Library (libgfortran)
+dnl This file is part of the GNU Fortran Runtime Library (libgfortran)
dnl Distributed under the GNU GPL with exception. See COPYING for details.
dnl
dnl Pass the implementation for a single section as the parameter to
extent[n] = 0;
}
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
size_t alloc_size, str;
return;
}
else
- retarray->data = internal_malloc_size (alloc_size);
+ retarray->base_addr = internal_malloc_size (alloc_size);
}
else
{
return;
}
- base = array->data;
+ base = array->base_addr;
if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
#ifdef HAVE_GFC_LOGICAL_16
else
internal_error (NULL, "Funny sized logical array in u_name intrinsic");
- dest = retarray->data;
+ dest = retarray->base_addr;
continue_loop = 1;
while (continue_loop)
`/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
}
if (packed)
- return source->data;
+ return source->base_addr;
/* Allocate storage for the destination. */
destptr = ('rtype_name` *)internal_malloc_size (ssize * sizeof ('rtype_name`));
dest = destptr;
- src = source->data;
+ src = source->base_addr;
stride0 = stride[0];
`/* Helper function for repacking arrays.
- Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
'rtype_name` * restrict dest;
int n;
- dest = d->data;
+ dest = d->base_addr;
if (src == dest || !src)
return;
`/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dimensioned [count, 1], so ycount=1.
*/
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof ('rtype_name`) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
ycount = GFC_DESCRIPTOR_EXTENT(b,1);
}
- abase = a->data;
- bbase = b->data;
- dest = retarray->data;
+ abase = a->base_addr;
+ bbase = b->base_addr;
+ dest = retarray->base_addr;
/* Now that everything is set up, we''`re performing the multiplication
`/* Implementation of the MATMUL intrinsic
- Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
assert (GFC_DESCRIPTOR_RANK (a) == 2
|| GFC_DESCRIPTOR_RANK (b) == 2);
- if (retarray->data == NULL)
+ if (retarray->base_addr == NULL)
{
if (GFC_DESCRIPTOR_RANK (a) == 1)
{
GFC_DESCRIPTOR_EXTENT(retarray,0));
}
- retarray->data
+ retarray->base_addr
= internal_malloc_size (sizeof ('rtype_name`) * size0 ((array_t *) retarray));
retarray->offset = 0;
}
}
}
- abase = a->data;
+ abase = a->base_addr;
a_kind = GFC_DESCRIPTOR_SIZE (a);
if (a_kind == 1 || a_kind == 2 || a_kind == 4 || a_kind == 8
else
internal_error (NULL, "Funny sized logical array");
- bbase = b->data;
+ bbase = b->base_addr;
b_kind = GFC_DESCRIPTOR_SIZE (b);
if (b_kind == 1 || b_kind == 2 || b_kind == 4 || b_kind == 8
else
internal_error (NULL, "Funny sized logical array");
- dest = retarray->data;
+ dest = retarray->base_addr;
'
sinclude(`matmul_asm_'rtype_code`.m4')dnl
`
`/* Specific implementation of the PACK intrinsic
- Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+ Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
dim = GFC_DESCRIPTOR_RANK (array);
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
if (zero_sized)
sptr = NULL;
else
- sptr = array->data;
+ sptr = array->base_addr;
- if (ret->data == NULL || unlikely (compile_options.bounds_check))
+ if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
{
/* Count the elements, either for allocating memory or
for bounds checking. */
total = count_0 (mask);
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* Setup the array descriptor. */
GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (sizeof ('rtype_name`) * total);
+ ret->base_addr = internal_malloc_size (sizeof ('rtype_name`) * total);
if (total == 0)
return;
rstride0 = 1;
sstride0 = sstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
+ rptr = ret->base_addr;
while (sptr && mptr)
{
if (vector)
{
n = GFC_DESCRIPTOR_EXTENT(vector,0);
- nelem = ((rptr - ret->data) / rstride0);
+ nelem = ((rptr - ret->base_addr) / rstride0);
if (n > nelem)
{
sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
if (sstride0 == 0)
sstride0 = 1;
- sptr = vector->data + sstride0 * nelem;
+ sptr = vector->base_addr + sstride0 * nelem;
n -= nelem;
while (n--)
{
`/* Implementation of the RESHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
for (n = 0; n < rdim; n++)
{
- shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+ shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
if (shape_data[n] <= 0)
{
shape_data[n] = 0;
}
}
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
index_type alloc_size;
else
alloc_size = rs * sizeof ('rtype_name`);
- ret->data = internal_malloc_size (alloc_size);
+ ret->base_addr = internal_malloc_size (alloc_size);
ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
}
else
psize = 0;
}
- pptr = pad->data;
+ pptr = pad->base_addr;
}
else
{
for (n = 0; n < rdim; n++)
{
- v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
if (v < 0 || v >= rdim)
runtime_error("Value %ld out of range in ORDER argument"
for (n = 0; n < rdim; n++)
{
if (order)
- dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+ dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
else
dim = n;
rsize *= sizeof ('rtype_name`);
ssize *= sizeof ('rtype_name`);
psize *= sizeof ('rtype_name`);
- reshape_packed ((char *)ret->data, rsize, (char *)source->data,
- ssize, pad ? (char *)pad->data : NULL, psize);
+ reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+ ssize, pad ? (char *)pad->base_addr : NULL, psize);
return;
}
- rptr = ret->data;
- src = sptr = source->data;
+ rptr = ret->base_addr;
+ src = sptr = source->base_addr;
rstride0 = rstride[0];
sstride0 = sstride[0];
`/* Implementation of the SHAPE intrinsic
- Copyright 2002, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
+ Copyright 2002, 2006, 2007, 2009, 2010, 2012 Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
rank = GFC_DESCRIPTOR_RANK (array);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
GFC_DIMENSION_SET(ret->dim[0], 0, rank - 1, 1);
ret->offset = 0;
- ret->data = internal_malloc_size (sizeof ('rtype_name`) * rank);
+ ret->base_addr = internal_malloc_size (sizeof ('rtype_name`) * rank);
}
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < rank; n++)
{
extent = GFC_DESCRIPTOR_EXTENT(array,n);
- ret->data[n * stride] = extent > 0 ? extent : 0 ;
+ ret->base_addr[n * stride] = extent > 0 ? extent : 0 ;
}
}
`/* Special implementation of the SPREAD intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
spread_generic.c written by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
ncopies = pncopies;
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
size_t ub, stride;
ret->offset = 0;
/* internal_malloc_size allocates a single byte for zero size. */
- ret->data = internal_malloc_size (rs * sizeof('rtype_name`));
+ ret->base_addr = internal_malloc_size (rs * sizeof('rtype_name`));
if (rs <= 0)
return;
}
}
sstride0 = sstride[0];
rstride0 = rstride[0];
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
while (sptr)
{
if (along > 1)
runtime_error ("dim outside of rank in spread()");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
- ret->data = internal_malloc_size (ncopies * sizeof ('rtype_name`));
+ ret->base_addr = internal_malloc_size (ncopies * sizeof ('rtype_name`));
ret->offset = 0;
GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
}
runtime_error ("dim too large in spread()");
}
- dest = ret->data;
+ dest = ret->base_addr;
stride = GFC_DESCRIPTOR_STRIDE(ret,0);
for (n = 0; n < ncopies; n++)
`/* Implementation of the TRANSPOSE intrinsic
- Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
Contributed by Tobias Schlüter
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
assert (GFC_DESCRIPTOR_RANK (source) == 2);
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
assert (GFC_DESCRIPTOR_RANK (ret) == 2);
assert (ret->dtype == source->dtype);
GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1,
GFC_DESCRIPTOR_EXTENT(source, 1));
- ret->data = internal_malloc_size (sizeof ('rtype_name`) * size0 ((array_t *) ret));
+ ret->base_addr = internal_malloc_size (sizeof ('rtype_name`) * size0 ((array_t *) ret));
ret->offset = 0;
} else if (unlikely (compile_options.bounds_check))
{
rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
- rptr = ret->data;
- sptr = source->data;
+ rptr = ret->base_addr;
+ sptr = source->base_addr;
for (y=0; y < ycount; y++)
{
`/* Specific implementation of the UNPACK intrinsic
- Copyright 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
unpack_generic.c by Paul Brook <paul@nowt.org>.
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof ('rtype_name`));
+ ret->base_addr = internal_malloc_size (rs * sizeof ('rtype_name`));
}
else
{
vstride0 = 1;
rstride0 = rstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
empty = 0;
- mptr = mask->data;
+ mptr = mask->base_addr;
/* Use the same loop for all logical types, by using GFC_LOGICAL_1
and using shifting to address size and endian issues. */
else
runtime_error ("Funny sized logical array");
- if (ret->data == NULL)
+ if (ret->base_addr == NULL)
{
/* The front end has signalled that we need to populate the
return array descriptor. */
rs *= extent[n];
}
ret->offset = 0;
- ret->data = internal_malloc_size (rs * sizeof ('rtype_name`));
+ ret->base_addr = internal_malloc_size (rs * sizeof ('rtype_name`));
}
else
{
rstride0 = rstride[0];
fstride0 = fstride[0];
mstride0 = mstride[0];
- rptr = ret->data;
- fptr = field->data;
- vptr = vector->data;
+ rptr = ret->base_addr;
+ fptr = field->base_addr;
+ vptr = vector->base_addr;
while (rptr)
{
-/* Copyright (C) 2009
+/* Copyright (C) 2009, 2012
Free Software Foundation, Inc.
Contributed by Thomas Koenig
rank = GFC_DESCRIPTOR_RANK (array);
kind = GFC_DESCRIPTOR_SIZE (array);
- base = array->data;
+ base = array->base_addr;
if (kind == 1 || kind == 2 || kind == 4 || kind == 8
#ifdef HAVE_GFC_LOGICAL_16
/* Generic helper function for repacking arrays.
- Copyright 2003, 2004, 2005, 2007, 2009, 2010
+ Copyright 2003, 2004, 2005, 2007, 2009, 2010, 2012
Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
#endif
case GFC_DTYPE_DERIVED_2:
- if (GFC_UNALIGNED_2(source->data))
+ if (GFC_UNALIGNED_2(source->base_addr))
break;
else
return internal_pack_2 ((gfc_array_i2 *) source);
case GFC_DTYPE_DERIVED_4:
- if (GFC_UNALIGNED_4(source->data))
+ if (GFC_UNALIGNED_4(source->base_addr))
break;
else
return internal_pack_4 ((gfc_array_i4 *) source);
case GFC_DTYPE_DERIVED_8:
- if (GFC_UNALIGNED_8(source->data))
+ if (GFC_UNALIGNED_8(source->base_addr))
break;
else
return internal_pack_8 ((gfc_array_i8 *) source);
#ifdef HAVE_GFC_INTEGER_16
case GFC_DTYPE_DERIVED_16:
- if (GFC_UNALIGNED_16(source->data))
+ if (GFC_UNALIGNED_16(source->base_addr))
break;
else
return internal_pack_16 ((gfc_array_i16 *) source);
}
if (packed)
- return source->data;
+ return source->base_addr;
/* Allocate storage for the destination. */
destptr = internal_malloc_size (ssize * size);
dest = (char *)destptr;
- src = source->data;
+ src = source->base_addr;
stride0 = stride[0] * size;
while (src)
/* Generic helper function for repacking arrays.
- Copyright 2003, 2004, 2005, 2007, 2009, 2010
+ Copyright 2003, 2004, 2005, 2007, 2009, 2010, 2012
Free Software Foundation, Inc.
Contributed by Paul Brook <paul@nowt.org>
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
int size;
int type_size;
- dest = d->data;
+ dest = d->base_addr;
/* This check may be redundant, but do it anyway. */
if (s == dest || !s)
return;
#endif
case GFC_DTYPE_DERIVED_2:
- if (GFC_UNALIGNED_2(d->data) || GFC_UNALIGNED_2(s))
+ if (GFC_UNALIGNED_2(d->base_addr) || GFC_UNALIGNED_2(s))
break;
else
{
return;
}
case GFC_DTYPE_DERIVED_4:
- if (GFC_UNALIGNED_4(d->data) || GFC_UNALIGNED_4(s))
+ if (GFC_UNALIGNED_4(d->base_addr) || GFC_UNALIGNED_4(s))
break;
else
{
}
case GFC_DTYPE_DERIVED_8:
- if (GFC_UNALIGNED_8(d->data) || GFC_UNALIGNED_8(s))
+ if (GFC_UNALIGNED_8(d->base_addr) || GFC_UNALIGNED_8(s))
break;
else
{
#ifdef HAVE_GFC_INTEGER_16
case GFC_DTYPE_DERIVED_16:
- if (GFC_UNALIGNED_16(d->data) || GFC_UNALIGNED_16(s))
+ if (GFC_UNALIGNED_16(d->base_addr) || GFC_UNALIGNED_16(s))
break;
else
{
projects / platform / upstream / gcc.git / commitdiff