+2008-01-13 Thomas Koenig <tkoenig@gcc.gnu.org>
+
+ PR libfortran/34746
+ * m4/iforeach.m4 (name`'rtype_qual`_'atype_code): Use %ld
+ in printf format for all bounds checking; cast all
+ integer-like arguments to runtime_error() to long int.
+ (`m'name`'rtype_qual`_'atype_code): Likewise.
+ (`s'name`'rtype_qual`_'atype_code): Likewise.
+ * m4/ifunction.m4 (name`'rtype_qual`_'atype_code): Likewise.
+ (`m'name`'rtype_qual`_'atype_code): Likewise.
+ (`s'name`'rtype_qual`_'atype_code): Likewise.
+ * generated/all_l16.c: Regenerated.
+ * generated/all_l4.c: Regenerated.
+ * generated/all_l8.c: Regenerated.
+ * generated/any_l16.c: Regenerated.
+ * generated/any_l4.c: Regenerated.
+ * generated/any_l8.c: Regenerated.
+ * generated/count_16_l16.c: Regenerated.
+ * generated/count_16_l4.c: Regenerated.
+ * generated/count_16_l8.c: Regenerated.
+ * generated/count_4_l16.c: Regenerated.
+ * generated/count_4_l4.c: Regenerated.
+ * generated/count_4_l8.c: Regenerated.
+ * generated/count_8_l16.c: Regenerated.
+ * generated/count_8_l4.c: Regenerated.
+ * generated/count_8_l8.c: Regenerated.
+ * generated/maxloc0_16_i1.c: Regenerated.
+ * generated/maxloc0_16_i16.c: Regenerated.
+ * generated/maxloc0_16_i2.c: Regenerated.
+ * generated/maxloc0_16_i4.c: Regenerated.
+ * generated/maxloc0_16_i8.c: Regenerated.
+ * generated/maxloc0_16_r10.c: Regenerated.
+ * generated/maxloc0_16_r16.c: Regenerated.
+ * generated/maxloc0_16_r4.c: Regenerated.
+ * generated/maxloc0_16_r8.c: Regenerated.
+ * generated/maxloc0_4_i1.c: Regenerated.
+ * generated/maxloc0_4_i16.c: Regenerated.
+ * generated/maxloc0_4_i2.c: Regenerated.
+ * generated/maxloc0_4_i4.c: Regenerated.
+ * generated/maxloc0_4_i8.c: Regenerated.
+ * generated/maxloc0_4_r10.c: Regenerated.
+ * generated/maxloc0_4_r16.c: Regenerated.
+ * generated/maxloc0_4_r4.c: Regenerated.
+ * generated/maxloc0_4_r8.c: Regenerated.
+ * generated/maxloc0_8_i1.c: Regenerated.
+ * generated/maxloc0_8_i16.c: Regenerated.
+ * generated/maxloc0_8_i2.c: Regenerated.
+ * generated/maxloc0_8_i4.c: Regenerated.
+ * generated/maxloc0_8_i8.c: Regenerated.
+ * generated/maxloc0_8_r10.c: Regenerated.
+ * generated/maxloc0_8_r16.c: Regenerated.
+ * generated/maxloc0_8_r4.c: Regenerated.
+ * generated/maxloc0_8_r8.c: Regenerated.
+ * generated/maxloc1_16_i1.c: Regenerated.
+ * generated/maxloc1_16_i16.c: Regenerated.
+ * generated/maxloc1_16_i2.c: Regenerated.
+ * generated/maxloc1_16_i4.c: Regenerated.
+ * generated/maxloc1_16_i8.c: Regenerated.
+ * generated/maxloc1_16_r10.c: Regenerated.
+ * generated/maxloc1_16_r16.c: Regenerated.
+ * generated/maxloc1_16_r4.c: Regenerated.
+ * generated/maxloc1_16_r8.c: Regenerated.
+ * generated/maxloc1_4_i1.c: Regenerated.
+ * generated/maxloc1_4_i16.c: Regenerated.
+ * generated/maxloc1_4_i2.c: Regenerated.
+ * generated/maxloc1_4_i4.c: Regenerated.
+ * generated/maxloc1_4_i8.c: Regenerated.
+ * generated/maxloc1_4_r10.c: Regenerated.
+ * generated/maxloc1_4_r16.c: Regenerated.
+ * generated/maxloc1_4_r4.c: Regenerated.
+ * generated/maxloc1_4_r8.c: Regenerated.
+ * generated/maxloc1_8_i1.c: Regenerated.
+ * generated/maxloc1_8_i16.c: Regenerated.
+ * generated/maxloc1_8_i2.c: Regenerated.
+ * generated/maxloc1_8_i4.c: Regenerated.
+ * generated/maxloc1_8_i8.c: Regenerated.
+ * generated/maxloc1_8_r10.c: Regenerated.
+ * generated/maxloc1_8_r16.c: Regenerated.
+ * generated/maxloc1_8_r4.c: Regenerated.
+ * generated/maxloc1_8_r8.c: Regenerated.
+ * generated/maxval_i1.c: Regenerated.
+ * generated/maxval_i16.c: Regenerated.
+ * generated/maxval_i2.c: Regenerated.
+ * generated/maxval_i4.c: Regenerated.
+ * generated/maxval_i8.c: Regenerated.
+ * generated/maxval_r10.c: Regenerated.
+ * generated/maxval_r16.c: Regenerated.
+ * generated/maxval_r4.c: Regenerated.
+ * generated/maxval_r8.c: Regenerated.
+ * generated/minloc0_16_i1.c: Regenerated.
+ * generated/minloc0_16_i16.c: Regenerated.
+ * generated/minloc0_16_i2.c: Regenerated.
+ * generated/minloc0_16_i4.c: Regenerated.
+ * generated/minloc0_16_i8.c: Regenerated.
+ * generated/minloc0_16_r10.c: Regenerated.
+ * generated/minloc0_16_r16.c: Regenerated.
+ * generated/minloc0_16_r4.c: Regenerated.
+ * generated/minloc0_16_r8.c: Regenerated.
+ * generated/minloc0_4_i1.c: Regenerated.
+ * generated/minloc0_4_i16.c: Regenerated.
+ * generated/minloc0_4_i2.c: Regenerated.
+ * generated/minloc0_4_i4.c: Regenerated.
+ * generated/minloc0_4_i8.c: Regenerated.
+ * generated/minloc0_4_r10.c: Regenerated.
+ * generated/minloc0_4_r16.c: Regenerated.
+ * generated/minloc0_4_r4.c: Regenerated.
+ * generated/minloc0_4_r8.c: Regenerated.
+ * generated/minloc0_8_i1.c: Regenerated.
+ * generated/minloc0_8_i16.c: Regenerated.
+ * generated/minloc0_8_i2.c: Regenerated.
+ * generated/minloc0_8_i4.c: Regenerated.
+ * generated/minloc0_8_i8.c: Regenerated.
+ * generated/minloc0_8_r10.c: Regenerated.
+ * generated/minloc0_8_r16.c: Regenerated.
+ * generated/minloc0_8_r4.c: Regenerated.
+ * generated/minloc0_8_r8.c: Regenerated.
+ * generated/minloc1_16_i1.c: Regenerated.
+ * generated/minloc1_16_i16.c: Regenerated.
+ * generated/minloc1_16_i2.c: Regenerated.
+ * generated/minloc1_16_i4.c: Regenerated.
+ * generated/minloc1_16_i8.c: Regenerated.
+ * generated/minloc1_16_r10.c: Regenerated.
+ * generated/minloc1_16_r16.c: Regenerated.
+ * generated/minloc1_16_r4.c: Regenerated.
+ * generated/minloc1_16_r8.c: Regenerated.
+ * generated/minloc1_4_i1.c: Regenerated.
+ * generated/minloc1_4_i16.c: Regenerated.
+ * generated/minloc1_4_i2.c: Regenerated.
+ * generated/minloc1_4_i4.c: Regenerated.
+ * generated/minloc1_4_i8.c: Regenerated.
+ * generated/minloc1_4_r10.c: Regenerated.
+ * generated/minloc1_4_r16.c: Regenerated.
+ * generated/minloc1_4_r4.c: Regenerated.
+ * generated/minloc1_4_r8.c: Regenerated.
+ * generated/minloc1_8_i1.c: Regenerated.
+ * generated/minloc1_8_i16.c: Regenerated.
+ * generated/minloc1_8_i2.c: Regenerated.
+ * generated/minloc1_8_i4.c: Regenerated.
+ * generated/minloc1_8_i8.c: Regenerated.
+ * generated/minloc1_8_r10.c: Regenerated.
+ * generated/minloc1_8_r16.c: Regenerated.
+ * generated/minloc1_8_r4.c: Regenerated.
+ * generated/minloc1_8_r8.c: Regenerated.
+ * generated/minval_i1.c: Regenerated.
+ * generated/minval_i16.c: Regenerated.
+ * generated/minval_i2.c: Regenerated.
+ * generated/minval_i4.c: Regenerated.
+ * generated/minval_i8.c: Regenerated.
+ * generated/minval_r10.c: Regenerated.
+ * generated/minval_r16.c: Regenerated.
+ * generated/minval_r4.c: Regenerated.
+ * generated/minval_r8.c: Regenerated.
+ * generated/product_c10.c: Regenerated.
+ * generated/product_c16.c: Regenerated.
+ * generated/product_c4.c: Regenerated.
+ * generated/product_c8.c: Regenerated.
+ * generated/product_i1.c: Regenerated.
+ * generated/product_i16.c: Regenerated.
+ * generated/product_i2.c: Regenerated.
+ * generated/product_i4.c: Regenerated.
+ * generated/product_i8.c: Regenerated.
+ * generated/product_r10.c: Regenerated.
+ * generated/product_r16.c: Regenerated.
+ * generated/product_r4.c: Regenerated.
+ * generated/product_r8.c: Regenerated.
+ * generated/sum_c10.c: Regenerated.
+ * generated/sum_c16.c: Regenerated.
+ * generated/sum_c4.c: Regenerated.
+ * generated/sum_c8.c: Regenerated.
+ * generated/sum_i1.c: Regenerated.
+ * generated/sum_i16.c: Regenerated.
+ * generated/sum_i2.c: Regenerated.
+ * generated/sum_i4.c: Regenerated.
+ * generated/sum_i8.c: Regenerated.
+ * generated/sum_r10.c: Regenerated.
+ * generated/sum_r16.c: Regenerated.
+ * generated/sum_r4.c: Regenerated.
+ * generated/sum_r8.c: Regenerated.
+
2008-01-11 Thomas Koenig <tkoenig@gcc.gnu.org>
PR libfortran/34670
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " ALL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " ALL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " ALL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " ALL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " ALL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " ALL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " ALL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " ALL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " ALL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " ALL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " ALL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " ALL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " ANY intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " ANY intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " ANY intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " ANY intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " ANY intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " ANY intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " ANY intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " ANY intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " ANY intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " ANY intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " ANY intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " ANY intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " COUNT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " COUNT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " COUNT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " COUNT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " COUNT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " COUNT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " COUNT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " COUNT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " COUNT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " COUNT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " COUNT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " COUNT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " COUNT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " COUNT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " COUNT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " COUNT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " COUNT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " COUNT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " COUNT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " COUNT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " COUNT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " COUNT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " COUNT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " COUNT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " COUNT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " COUNT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " COUNT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " COUNT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " COUNT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " COUNT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " COUNT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " COUNT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " COUNT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " COUNT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " COUNT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " COUNT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MAXLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MAXLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MAXVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MAXVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MAXVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MAXVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MAXVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " MINLOC intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in MINLOC intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINLOC intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINLOC intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINLOC intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINLOC intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINLOC intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " MINVAL intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " MINVAL intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " MINVAL intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " MINVAL intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in MINVAL intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " PRODUCT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " PRODUCT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in PRODUCT intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " PRODUCT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " PRODUCT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in PRODUCT intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " PRODUCT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " PRODUCT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in PRODUCT intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " PRODUCT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " PRODUCT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in PRODUCT intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " PRODUCT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " PRODUCT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in PRODUCT intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " PRODUCT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " PRODUCT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in PRODUCT intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " PRODUCT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " PRODUCT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in PRODUCT intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " PRODUCT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " PRODUCT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in PRODUCT intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " PRODUCT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " PRODUCT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in PRODUCT intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " PRODUCT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " PRODUCT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in PRODUCT intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " PRODUCT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " PRODUCT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in PRODUCT intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " PRODUCT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " PRODUCT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in PRODUCT intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " PRODUCT intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " PRODUCT intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " PRODUCT intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " PRODUCT intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in PRODUCT intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " SUM intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " SUM intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in SUM intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " SUM intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " SUM intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in SUM intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " SUM intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " SUM intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in SUM intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " SUM intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " SUM intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in SUM intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " SUM intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " SUM intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in SUM intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " SUM intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " SUM intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in SUM intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " SUM intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " SUM intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in SUM intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " SUM intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " SUM intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in SUM intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " SUM intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " SUM intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in SUM intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " SUM intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " SUM intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in SUM intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " SUM intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " SUM intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in SUM intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " SUM intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " SUM intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in SUM intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " SUM intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " SUM intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " SUM intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " SUM intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in SUM intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in u_name intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " u_name intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " u_name intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in u_name intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
runtime_error ("Incorrect extent in return value of"
- " u_name intrnisic: is %ld, should be %d",
- (long int) ret_extent, rank);
+ " u_name intrnisic: is %ld, should be %ld",
+ (long int) ret_extent, (long int) rank);
mask_rank = GFC_DESCRIPTOR_RANK (mask);
if (rank != mask_rank)
runtime_error ("rank of MASK argument in u_name intrnisic"
- "should be %d, is %d", rank, mask_rank);
+ "should be %ld, is %ld", (long int) rank,
+ (long int) mask_rank);
for (n=0; n<rank; n++)
{
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " u_name intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " u_name intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in u_name intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
{
if (rank != GFC_DESCRIPTOR_RANK (retarray))
runtime_error ("rank of return array incorrect in"
- " u_name intrinsic: is %d, should be %d",
- GFC_DESCRIPTOR_RANK (retarray), rank);
+ " u_name intrinsic: is %ld, should be %ld",
+ (long int) (GFC_DESCRIPTOR_RANK (retarray)),
+ (long int) rank);
if (compile_options.bounds_check)
{
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " u_name intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " u_name intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
}
- retarray->dim[n].lbound;
if (extent[n] != ret_extent)
runtime_error ("Incorrect extent in return value of"
- " u_name intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " u_name intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) ret_extent, (long int) extent[n]);
}
for (n=0; n<= rank; n++)
mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
if (array_extent != mask_extent)
runtime_error ("Incorrect extent in MASK argument of"
- " u_name intrinsic in dimension %d:"
- " is %ld, should be %ld", n + 1,
+ " u_name intrinsic in dimension %ld:"
+ " is %ld, should be %ld", (long int) n + 1,
(long int) mask_extent, (long int) array_extent);
}
}
ret_rank = GFC_DESCRIPTOR_RANK (retarray);
if (ret_rank != 1)
runtime_error ("rank of return array in u_name intrinsic"
- " should be 1, is %d", ret_rank);
+ " should be 1, is %ld", (long int) ret_rank);
ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
if (ret_extent != rank)
projects / platform / upstream / gcc.git / commitdiff