diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog
index 34b730795e1590d1d4e0ebb8eb146833a023cbbd..16ef713c4b5fa037246e224160ebc7120788c23c 100644
--- a/libgfortran/ChangeLog
+++ b/libgfortran/ChangeLog
@@ -1,3 +1,182 @@
+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
diff --git a/libgfortran/generated/all_l16.c b/libgfortran/generated/all_l16.c
index 2cc81ce423a09d59c02d212fd333c9806af455ae..9c53707ae762a537582202e3d9e976a77396e24b 100644
--- a/libgfortran/generated/all_l16.c
+++ b/libgfortran/generated/all_l16.c
@@ -116,8 +116,9 @@ all_l16 (gfc_array_l16 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ all_l16 (gfc_array_l16 * const restrict retarray,
- 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]);
}
}
diff --git a/libgfortran/generated/all_l4.c b/libgfortran/generated/all_l4.c
index 12f9efb2b915a81ee92c268b1c4ec10fa73e28d7..6eb798619b6b53bddc6fec67f9d86e066ab1f3fe 100644
--- a/libgfortran/generated/all_l4.c
+++ b/libgfortran/generated/all_l4.c
@@ -116,8 +116,9 @@ all_l4 (gfc_array_l4 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ all_l4 (gfc_array_l4 * const restrict retarray,
- 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]);
}
}
diff --git a/libgfortran/generated/all_l8.c b/libgfortran/generated/all_l8.c
index c9fa80935ae82a93d70221e755ded43776da1337..7b98652bce52b3f7518f4e675adc940937e5bc11 100644
--- a/libgfortran/generated/all_l8.c
+++ b/libgfortran/generated/all_l8.c
@@ -116,8 +116,9 @@ all_l8 (gfc_array_l8 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ all_l8 (gfc_array_l8 * const restrict retarray,
- 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]);
}
}
diff --git a/libgfortran/generated/any_l16.c b/libgfortran/generated/any_l16.c
index 1ba59edbadd12d283f7e0b830e4b73f702ef603c..bffd620f02b994de24502ba9278d863e5ac1cdb1 100644
--- a/libgfortran/generated/any_l16.c
+++ b/libgfortran/generated/any_l16.c
@@ -116,8 +116,9 @@ any_l16 (gfc_array_l16 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ any_l16 (gfc_array_l16 * const restrict retarray,
- 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]);
}
}
diff --git a/libgfortran/generated/any_l4.c b/libgfortran/generated/any_l4.c
index 83116ebe9cac58c4a59daa079d2a7713e7d51b97..f86445e69e1f0e2246ef807eac804a1a5374a228 100644
--- a/libgfortran/generated/any_l4.c
+++ b/libgfortran/generated/any_l4.c
@@ -116,8 +116,9 @@ any_l4 (gfc_array_l4 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ any_l4 (gfc_array_l4 * const restrict retarray,
- 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]);
}
}
diff --git a/libgfortran/generated/any_l8.c b/libgfortran/generated/any_l8.c
index a85e6e89ca0dbdf5dcf91bc181f7b051c16dcd6d..f155abbed362e70f943f2a1d8e9a71388998a896 100644
--- a/libgfortran/generated/any_l8.c
+++ b/libgfortran/generated/any_l8.c
@@ -116,8 +116,9 @@ any_l8 (gfc_array_l8 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ any_l8 (gfc_array_l8 * const restrict retarray,
- 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]);
}
}
diff --git a/libgfortran/generated/count_16_l16.c b/libgfortran/generated/count_16_l16.c
index 351eb8a1e6562dea98fb4f4661762c74ef7d74a8..4f3418bd73a12c413b75efb1ef04492b6f185964 100644
--- a/libgfortran/generated/count_16_l16.c
+++ b/libgfortran/generated/count_16_l16.c
@@ -116,8 +116,9 @@ count_16_l16 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ count_16_l16 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
diff --git a/libgfortran/generated/count_16_l4.c b/libgfortran/generated/count_16_l4.c
index 9f849d8b725609851144fa2a0127551efc032d6e..9b853699b9de50d2a11d474c8f4f1a681730cf7b 100644
--- a/libgfortran/generated/count_16_l4.c
+++ b/libgfortran/generated/count_16_l4.c
@@ -116,8 +116,9 @@ count_16_l4 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ count_16_l4 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
diff --git a/libgfortran/generated/count_16_l8.c b/libgfortran/generated/count_16_l8.c
index 90659da0a1775a2f8696e1a98a25fd9a264132f5..7a6a31adf0cd8acc8304ca38835aae89516b0729 100644
--- a/libgfortran/generated/count_16_l8.c
+++ b/libgfortran/generated/count_16_l8.c
@@ -116,8 +116,9 @@ count_16_l8 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ count_16_l8 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
diff --git a/libgfortran/generated/count_4_l16.c b/libgfortran/generated/count_4_l16.c
index c3b3daad85a518481f317b249af8f06a2892bf6c..5dee5468c6486f2399c7c73e084226c9843ff362 100644
--- a/libgfortran/generated/count_4_l16.c
+++ b/libgfortran/generated/count_4_l16.c
@@ -116,8 +116,9 @@ count_4_l16 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ count_4_l16 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
diff --git a/libgfortran/generated/count_4_l4.c b/libgfortran/generated/count_4_l4.c
index 3bfcf179c75a345a4b46cb2937032391ca8caf01..04493b2f4b4ff16a7a3598040ba65793e95eb730 100644
--- a/libgfortran/generated/count_4_l4.c
+++ b/libgfortran/generated/count_4_l4.c
@@ -116,8 +116,9 @@ count_4_l4 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ count_4_l4 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
diff --git a/libgfortran/generated/count_4_l8.c b/libgfortran/generated/count_4_l8.c
index 7debda799bbd9ce68212427170a64663fe65d6e5..0e2f9bbb5439e40d85671c1f33687b199ea15232 100644
--- a/libgfortran/generated/count_4_l8.c
+++ b/libgfortran/generated/count_4_l8.c
@@ -116,8 +116,9 @@ count_4_l8 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ count_4_l8 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
diff --git a/libgfortran/generated/count_8_l16.c b/libgfortran/generated/count_8_l16.c
index 815b79ab65cbf901ddad23347022424093de9bda..b0d11164fc530e9b92cfe382b2fe3953482bf355 100644
--- a/libgfortran/generated/count_8_l16.c
+++ b/libgfortran/generated/count_8_l16.c
@@ -116,8 +116,9 @@ count_8_l16 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ count_8_l16 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
diff --git a/libgfortran/generated/count_8_l4.c b/libgfortran/generated/count_8_l4.c
index 84401ded1e15c3a407a8e037a6caeb74d5921436..e6a386e8a8d2929d28870a781b5a4cf32892cfbe 100644
--- a/libgfortran/generated/count_8_l4.c
+++ b/libgfortran/generated/count_8_l4.c
@@ -116,8 +116,9 @@ count_8_l4 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ count_8_l4 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
diff --git a/libgfortran/generated/count_8_l8.c b/libgfortran/generated/count_8_l8.c
index fd26280a550c1e5893c992da6c8fb7d96f7bdf70..2a1b2a570de005d116f02cb76d162d4beb8ceb47 100644
--- a/libgfortran/generated/count_8_l8.c
+++ b/libgfortran/generated/count_8_l8.c
@@ -116,8 +116,9 @@ count_8_l8 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ count_8_l8 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
diff --git a/libgfortran/generated/maxloc0_16_i1.c b/libgfortran/generated/maxloc0_16_i1.c
index 3cd6554a3460f96664558124127362ff09162501..7fc44432fa44cc143da3bcaff869e766aad9e933 100644
--- a/libgfortran/generated/maxloc0_16_i1.c
+++ b/libgfortran/generated/maxloc0_16_i1.c
@@ -77,13 +77,13 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_16_i16.c b/libgfortran/generated/maxloc0_16_i16.c
index 9bfec04301311e808f9b2303a09f7edf83db62e2..29eb3ccecf13ca325f284c26c78d4881af928a2a 100644
--- a/libgfortran/generated/maxloc0_16_i16.c
+++ b/libgfortran/generated/maxloc0_16_i16.c
@@ -77,13 +77,13 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_16_i2.c b/libgfortran/generated/maxloc0_16_i2.c
index b57e78f927468b9733310fd16db8369efe67af68..30b693c1068f439360a6f1302218f085a214e8bc 100644
--- a/libgfortran/generated/maxloc0_16_i2.c
+++ b/libgfortran/generated/maxloc0_16_i2.c
@@ -77,13 +77,13 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_16_i4.c b/libgfortran/generated/maxloc0_16_i4.c
index 2e123b6d2959265d723efe7264d49c5784f255f7..03f2794f30badbd1e0edf35ede8d760c4512b178 100644
--- a/libgfortran/generated/maxloc0_16_i4.c
+++ b/libgfortran/generated/maxloc0_16_i4.c
@@ -77,13 +77,13 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_16_i8.c b/libgfortran/generated/maxloc0_16_i8.c
index cd141a692227dbbe95b69d66bd4e6c0b3902b074..be18af39ce8e467efb06d36006690ffefe0f0476 100644
--- a/libgfortran/generated/maxloc0_16_i8.c
+++ b/libgfortran/generated/maxloc0_16_i8.c
@@ -77,13 +77,13 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_16_r10.c b/libgfortran/generated/maxloc0_16_r10.c
index 8426d3af81e4a4034e85dcf504c8ff528b5606a4..48ba77e8732af3323085ea630fea0da75556b5b1 100644
--- a/libgfortran/generated/maxloc0_16_r10.c
+++ b/libgfortran/generated/maxloc0_16_r10.c
@@ -77,13 +77,13 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_16_r16.c b/libgfortran/generated/maxloc0_16_r16.c
index 3244452c601e85d089a438294bfe413d258653f6..9d2ce0870153a74f3b8326b13c62f255e5dfbcc0 100644
--- a/libgfortran/generated/maxloc0_16_r16.c
+++ b/libgfortran/generated/maxloc0_16_r16.c
@@ -77,13 +77,13 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_16_r4.c b/libgfortran/generated/maxloc0_16_r4.c
index 8057063339c4f50629248fce78e8a524f62118f8..e908dadcdd0c42fa6af1fc874ddc9f03b5d6d4df 100644
--- a/libgfortran/generated/maxloc0_16_r4.c
+++ b/libgfortran/generated/maxloc0_16_r4.c
@@ -77,13 +77,13 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_16_r8.c b/libgfortran/generated/maxloc0_16_r8.c
index 6c12815a0a11ca593899949469657ff25ab755d5..cb01745a44c19b11ec1588b08616e8d995b14a6f 100644
--- a/libgfortran/generated/maxloc0_16_r8.c
+++ b/libgfortran/generated/maxloc0_16_r8.c
@@ -77,13 +77,13 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_4_i1.c b/libgfortran/generated/maxloc0_4_i1.c
index 42c865a6e29bd134b92e04d8e3853ada529294c0..21ab578c4025c69dad10c13ac6868b44bafa67c0 100644
--- a/libgfortran/generated/maxloc0_4_i1.c
+++ b/libgfortran/generated/maxloc0_4_i1.c
@@ -77,13 +77,13 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_4_i16.c b/libgfortran/generated/maxloc0_4_i16.c
index 938ceba697470dc9e288a1ae7ead55c52ada2171..6803420884c7345b3559100629ae73a83c7025ed 100644
--- a/libgfortran/generated/maxloc0_4_i16.c
+++ b/libgfortran/generated/maxloc0_4_i16.c
@@ -77,13 +77,13 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_4_i2.c b/libgfortran/generated/maxloc0_4_i2.c
index 809d93821dc56e3c9e958822d7bb0b21e63ffc79..27cccae9784341a88de0bf3b6d2272f7f79ca165 100644
--- a/libgfortran/generated/maxloc0_4_i2.c
+++ b/libgfortran/generated/maxloc0_4_i2.c
@@ -77,13 +77,13 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_4_i4.c b/libgfortran/generated/maxloc0_4_i4.c
index 5108cbe1366035dd45eb011a5e0e179032d3942f..650da03a1ed0473d9b9ebc594ca95c8c2bcdc2d7 100644
--- a/libgfortran/generated/maxloc0_4_i4.c
+++ b/libgfortran/generated/maxloc0_4_i4.c
@@ -77,13 +77,13 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_4_i8.c b/libgfortran/generated/maxloc0_4_i8.c
index 987b424d7e16ff748b001798f4e6fd14560075e4..48e1d3e521579456190b3d6e50143c7825819e82 100644
--- a/libgfortran/generated/maxloc0_4_i8.c
+++ b/libgfortran/generated/maxloc0_4_i8.c
@@ -77,13 +77,13 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_4_r10.c b/libgfortran/generated/maxloc0_4_r10.c
index b3101bd6ac8d2cb275d5bef509d397df8ebf1c4d..05e316592386ee316e9aba65ffac2673593676fc 100644
--- a/libgfortran/generated/maxloc0_4_r10.c
+++ b/libgfortran/generated/maxloc0_4_r10.c
@@ -77,13 +77,13 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_4_r16.c b/libgfortran/generated/maxloc0_4_r16.c
index 9b1e5274a3f905e4557d8092f8913fddb3aa5d97..38cf35272825209964f542e8fa01908ee7322bf4 100644
--- a/libgfortran/generated/maxloc0_4_r16.c
+++ b/libgfortran/generated/maxloc0_4_r16.c
@@ -77,13 +77,13 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_4_r4.c b/libgfortran/generated/maxloc0_4_r4.c
index bf4692c26f08fa7ea5e2309c7b662385019e9a51..5ab9429028ebc986368add7638be0bdab96f4f37 100644
--- a/libgfortran/generated/maxloc0_4_r4.c
+++ b/libgfortran/generated/maxloc0_4_r4.c
@@ -77,13 +77,13 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_4_r8.c b/libgfortran/generated/maxloc0_4_r8.c
index 774a6734c2d21a8934d4cb80f8b48e7b9d43e34b..2658e4a5b9ac0ef29307be6405e42971a87df0ac 100644
--- a/libgfortran/generated/maxloc0_4_r8.c
+++ b/libgfortran/generated/maxloc0_4_r8.c
@@ -77,13 +77,13 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_8_i1.c b/libgfortran/generated/maxloc0_8_i1.c
index 38890b70dcfb919426157cf072d768a98746ef89..ce71eb1ebbdabafc5ea1694c7f1e821e7e7d3917 100644
--- a/libgfortran/generated/maxloc0_8_i1.c
+++ b/libgfortran/generated/maxloc0_8_i1.c
@@ -77,13 +77,13 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_8_i16.c b/libgfortran/generated/maxloc0_8_i16.c
index be99a8ca0b10301616fe9104847342c3b3b1f4da..e808a91cf5968ce934d99d89d4ee17c54a039030 100644
--- a/libgfortran/generated/maxloc0_8_i16.c
+++ b/libgfortran/generated/maxloc0_8_i16.c
@@ -77,13 +77,13 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_8_i2.c b/libgfortran/generated/maxloc0_8_i2.c
index 02a5f645e8ec4e1288a8695a8ef0b6177762816d..8bc1961ea3a7bc703136f1b328c01dc27e3e80dc 100644
--- a/libgfortran/generated/maxloc0_8_i2.c
+++ b/libgfortran/generated/maxloc0_8_i2.c
@@ -77,13 +77,13 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_8_i4.c b/libgfortran/generated/maxloc0_8_i4.c
index dca0b768861c3039eca0a9169b5ec928d5b47fa2..8b6d2128a5dd106cfe2afbfc67ab922096ff5535 100644
--- a/libgfortran/generated/maxloc0_8_i4.c
+++ b/libgfortran/generated/maxloc0_8_i4.c
@@ -77,13 +77,13 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_8_i8.c b/libgfortran/generated/maxloc0_8_i8.c
index d11ba2677f2ba8028aa0e761a0a92d6fa4d295e6..121827eabb343a05775253aab8782bac0b86dc24 100644
--- a/libgfortran/generated/maxloc0_8_i8.c
+++ b/libgfortran/generated/maxloc0_8_i8.c
@@ -77,13 +77,13 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_8_r10.c b/libgfortran/generated/maxloc0_8_r10.c
index 898f1f576736f679b34c18af48c65e3427ea1d09..8fb4b13eb6953d7d74bd54625f83a11ed9ef3c2f 100644
--- a/libgfortran/generated/maxloc0_8_r10.c
+++ b/libgfortran/generated/maxloc0_8_r10.c
@@ -77,13 +77,13 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_8_r16.c b/libgfortran/generated/maxloc0_8_r16.c
index 6dec78a49f96389a4d5cfae73e7213b96d977298..7a5a4f354af7e3e43bcc1e564a353aaab3ea4630 100644
--- a/libgfortran/generated/maxloc0_8_r16.c
+++ b/libgfortran/generated/maxloc0_8_r16.c
@@ -77,13 +77,13 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_8_r4.c b/libgfortran/generated/maxloc0_8_r4.c
index 345dbe1a9d160e537235536cd2fc741b136e1e56..8e02dcb771809222ee0141af371f6cd4515fbdc5 100644
--- a/libgfortran/generated/maxloc0_8_r4.c
+++ b/libgfortran/generated/maxloc0_8_r4.c
@@ -77,13 +77,13 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc0_8_r8.c b/libgfortran/generated/maxloc0_8_r8.c
index bf7020e1a101b641d9c821eda2c9bae5956fbc0c..c539df0596d83c1b6a668e6655875a0628b2ad1a 100644
--- a/libgfortran/generated/maxloc0_8_r8.c
+++ b/libgfortran/generated/maxloc0_8_r8.c
@@ -77,13 +77,13 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ smaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_16_i1.c b/libgfortran/generated/maxloc1_16_i1.c
index 477eb704a868bd5dabddbfc23d2918254e87f572..47e67239322cd8520ca9932d5b5f60675420089e 100644
--- a/libgfortran/generated/maxloc1_16_i1.c
+++ b/libgfortran/generated/maxloc1_16_i1.c
@@ -117,8 +117,9 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_16_i16.c b/libgfortran/generated/maxloc1_16_i16.c
index e4a2c1b361b9527d6fc555d1c6f85f4d6bae2920..2c8a06cb6757a4260a6d8a913d99f53e3a56e905 100644
--- a/libgfortran/generated/maxloc1_16_i16.c
+++ b/libgfortran/generated/maxloc1_16_i16.c
@@ -117,8 +117,9 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_16_i2.c b/libgfortran/generated/maxloc1_16_i2.c
index f5d7b587aed231552695fc37f1a37ddcd9e4b645..d7b1ca57eede2b50d82f5de4c079421731a80e36 100644
--- a/libgfortran/generated/maxloc1_16_i2.c
+++ b/libgfortran/generated/maxloc1_16_i2.c
@@ -117,8 +117,9 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_16_i4.c b/libgfortran/generated/maxloc1_16_i4.c
index 1fbda541ae3e294571133323224baeffa019135a..394c0160261d0f8e5ee2f1a60d046f97e50f7907 100644
--- a/libgfortran/generated/maxloc1_16_i4.c
+++ b/libgfortran/generated/maxloc1_16_i4.c
@@ -117,8 +117,9 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_16_i8.c b/libgfortran/generated/maxloc1_16_i8.c
index 59be84cd62c010e834a2c44e18372300a613603c..5cff65dece47f2b0a23f0c2e618c9b9d2d354bc4 100644
--- a/libgfortran/generated/maxloc1_16_i8.c
+++ b/libgfortran/generated/maxloc1_16_i8.c
@@ -117,8 +117,9 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_16_r10.c b/libgfortran/generated/maxloc1_16_r10.c
index 3a8c8b7a376e6a6842348049261f7a598f29077c..32af8cd88544e30f949ac794235a9f48aab6e186 100644
--- a/libgfortran/generated/maxloc1_16_r10.c
+++ b/libgfortran/generated/maxloc1_16_r10.c
@@ -117,8 +117,9 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_16_r16.c b/libgfortran/generated/maxloc1_16_r16.c
index 60b97249adae3e32362a104d50f84bb06ee5e782..d695ad8ec5d6157d363ac2f54010daae45852faf 100644
--- a/libgfortran/generated/maxloc1_16_r16.c
+++ b/libgfortran/generated/maxloc1_16_r16.c
@@ -117,8 +117,9 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_16_r4.c b/libgfortran/generated/maxloc1_16_r4.c
index a36a9d1133c6e7406b9ed35a861d4bc36b847f8e..05dfbe380a7e891acc1c18991b22a5fcde5a9f37 100644
--- a/libgfortran/generated/maxloc1_16_r4.c
+++ b/libgfortran/generated/maxloc1_16_r4.c
@@ -117,8 +117,9 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_16_r8.c b/libgfortran/generated/maxloc1_16_r8.c
index 9c659c0d3a6ada8bc7db2fb04462c747838d9ba4..a060e0620a8a57aae25552ec6e4613297e07980d 100644
--- a/libgfortran/generated/maxloc1_16_r8.c
+++ b/libgfortran/generated/maxloc1_16_r8.c
@@ -117,8 +117,9 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_4_i1.c b/libgfortran/generated/maxloc1_4_i1.c
index 1d9132888cd1f56e826570a93032c1bd3977c6f7..2244456c15448d5fd9e51e4574fe13bc45d1dbdf 100644
--- a/libgfortran/generated/maxloc1_4_i1.c
+++ b/libgfortran/generated/maxloc1_4_i1.c
@@ -117,8 +117,9 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_4_i16.c b/libgfortran/generated/maxloc1_4_i16.c
index 92a08bef0bd214ba857b7860e512c522694cccb4..d0f260c962d99a4b5f864513ffcfe31f25f43f02 100644
--- a/libgfortran/generated/maxloc1_4_i16.c
+++ b/libgfortran/generated/maxloc1_4_i16.c
@@ -117,8 +117,9 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_4_i2.c b/libgfortran/generated/maxloc1_4_i2.c
index b03d90a9592011fa159282ceebf6b9486c9c2c9b..5415ebabacfa82155cb26ca67a3f7a514a241a1c 100644
--- a/libgfortran/generated/maxloc1_4_i2.c
+++ b/libgfortran/generated/maxloc1_4_i2.c
@@ -117,8 +117,9 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_4_i4.c b/libgfortran/generated/maxloc1_4_i4.c
index dc90ec29d8da128df22533d2bd07611ba2e53cc3..291b919945d0d4edd30ec1d7582513afa17ea389 100644
--- a/libgfortran/generated/maxloc1_4_i4.c
+++ b/libgfortran/generated/maxloc1_4_i4.c
@@ -117,8 +117,9 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_4_i8.c b/libgfortran/generated/maxloc1_4_i8.c
index 78da94438cd67d6376e74c3869414871dd0e2e6f..97a904dc6875eb68b807529a286916c52c75561e 100644
--- a/libgfortran/generated/maxloc1_4_i8.c
+++ b/libgfortran/generated/maxloc1_4_i8.c
@@ -117,8 +117,9 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_4_r10.c b/libgfortran/generated/maxloc1_4_r10.c
index 1c83f62f7289f8fe860c1efd08d67a1af2e8ebcd..07ccb242ae4bfed001cf7a70dc926dd2e4b4513e 100644
--- a/libgfortran/generated/maxloc1_4_r10.c
+++ b/libgfortran/generated/maxloc1_4_r10.c
@@ -117,8 +117,9 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_4_r16.c b/libgfortran/generated/maxloc1_4_r16.c
index a31d0ac5afaa1a06a860a6bfa1710ca268a2df13..5ecfffd7b044eff3c8ca961607066a1af14eb367 100644
--- a/libgfortran/generated/maxloc1_4_r16.c
+++ b/libgfortran/generated/maxloc1_4_r16.c
@@ -117,8 +117,9 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_4_r4.c b/libgfortran/generated/maxloc1_4_r4.c
index 49d9cd5463bbdccba9cb6dfdd0af059badaf1ca0..f859cc761996f9606c2650ffa645ddaf749ad99f 100644
--- a/libgfortran/generated/maxloc1_4_r4.c
+++ b/libgfortran/generated/maxloc1_4_r4.c
@@ -117,8 +117,9 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_4_r8.c b/libgfortran/generated/maxloc1_4_r8.c
index 822680a494112647dbb748122d3deaa0450daf7b..5d673420fd9e265e4cdf30229583c18e3d06bc5c 100644
--- a/libgfortran/generated/maxloc1_4_r8.c
+++ b/libgfortran/generated/maxloc1_4_r8.c
@@ -117,8 +117,9 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_8_i1.c b/libgfortran/generated/maxloc1_8_i1.c
index 5c607532dbc147d6b9fc513b1e934a8a7d751ec1..f9ea707ab95df62c61fe5f023fd9d2f5da678597 100644
--- a/libgfortran/generated/maxloc1_8_i1.c
+++ b/libgfortran/generated/maxloc1_8_i1.c
@@ -117,8 +117,9 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_8_i16.c b/libgfortran/generated/maxloc1_8_i16.c
index feefc084883e47547788420bf869d0b77f0b4174..478a8bc87b0c662d6350ff128ab74f1a4e170d2e 100644
--- a/libgfortran/generated/maxloc1_8_i16.c
+++ b/libgfortran/generated/maxloc1_8_i16.c
@@ -117,8 +117,9 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_8_i2.c b/libgfortran/generated/maxloc1_8_i2.c
index 8e4868d73080a3cb6bde5705e04c1d3b47ca2904..972767f6558a4c6b77a7548d52688292d3bfc73e 100644
--- a/libgfortran/generated/maxloc1_8_i2.c
+++ b/libgfortran/generated/maxloc1_8_i2.c
@@ -117,8 +117,9 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_8_i4.c b/libgfortran/generated/maxloc1_8_i4.c
index cb9d14d8d1d7f0cd4bb01780ba2ece54148c373c..e3b566d57ec4c78b6c0752b5b514d15f15dba8a9 100644
--- a/libgfortran/generated/maxloc1_8_i4.c
+++ b/libgfortran/generated/maxloc1_8_i4.c
@@ -117,8 +117,9 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_8_i8.c b/libgfortran/generated/maxloc1_8_i8.c
index 8b8f2a969145272297878095a7727aa768267f68..e30e104dfc6a787aa81edc080cd78e82fbfc0f3e 100644
--- a/libgfortran/generated/maxloc1_8_i8.c
+++ b/libgfortran/generated/maxloc1_8_i8.c
@@ -117,8 +117,9 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_8_r10.c b/libgfortran/generated/maxloc1_8_r10.c
index 6aa6ec1941c4db40a51f18427a93e17a5bddc08d..01e30f660e44abfcfb8be1d8f8c50e32ca6ae2bb 100644
--- a/libgfortran/generated/maxloc1_8_r10.c
+++ b/libgfortran/generated/maxloc1_8_r10.c
@@ -117,8 +117,9 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_8_r16.c b/libgfortran/generated/maxloc1_8_r16.c
index 59db207cfc00bc677e39d7c6e99b9e8572110ccd..fbe72d1874fa0834ff09e32ec43a3cfdff8ecd9d 100644
--- a/libgfortran/generated/maxloc1_8_r16.c
+++ b/libgfortran/generated/maxloc1_8_r16.c
@@ -117,8 +117,9 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_8_r4.c b/libgfortran/generated/maxloc1_8_r4.c
index 3640a5dea9633ed8ba891e853aea45a771151d09..3985d684fe4f9c9831ceff10c7662f33529b3a42 100644
--- a/libgfortran/generated/maxloc1_8_r4.c
+++ b/libgfortran/generated/maxloc1_8_r4.c
@@ -117,8 +117,9 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxloc1_8_r8.c b/libgfortran/generated/maxloc1_8_r8.c
index 93c7c78aec743759e7ac74acf5b0e9d8508c5a55..6e7745b31ba975872e47c5e99c67f73a83a55a09 100644
--- a/libgfortran/generated/maxloc1_8_r8.c
+++ b/libgfortran/generated/maxloc1_8_r8.c
@@ -117,8 +117,9 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ smaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxval_i1.c b/libgfortran/generated/maxval_i1.c
index 5158e2a60cc54e1d0b575f6fc1ef3d796d12dfca..901f4e7f2a7fa903884ea2b9052118b8cf584249 100644
--- a/libgfortran/generated/maxval_i1.c
+++ b/libgfortran/generated/maxval_i1.c
@@ -116,8 +116,9 @@ maxval_i1 (gfc_array_i1 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ maxval_i1 (gfc_array_i1 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ smaxval_i1 (gfc_array_i1 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxval_i16.c b/libgfortran/generated/maxval_i16.c
index a10c8fa57c9e2270df451e2b5dd8c18abdb3701e..c082e856922d92530ae61c7269833ac985dfbbc9 100644
--- a/libgfortran/generated/maxval_i16.c
+++ b/libgfortran/generated/maxval_i16.c
@@ -116,8 +116,9 @@ maxval_i16 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ maxval_i16 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ smaxval_i16 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxval_i2.c b/libgfortran/generated/maxval_i2.c
index 3819e0e01017a5c78ee1e4af085b0cf34deab3c1..87865e1b49b123252b9fcd3a31c72cc7d224a318 100644
--- a/libgfortran/generated/maxval_i2.c
+++ b/libgfortran/generated/maxval_i2.c
@@ -116,8 +116,9 @@ maxval_i2 (gfc_array_i2 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ maxval_i2 (gfc_array_i2 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ smaxval_i2 (gfc_array_i2 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxval_i4.c b/libgfortran/generated/maxval_i4.c
index 1076336a02fb221c9a45fb1422934c0c03c46c9b..3fa4a10b1bf5f56ec613a6f142ba7389101ef5c4 100644
--- a/libgfortran/generated/maxval_i4.c
+++ b/libgfortran/generated/maxval_i4.c
@@ -116,8 +116,9 @@ maxval_i4 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ maxval_i4 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ smaxval_i4 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxval_i8.c b/libgfortran/generated/maxval_i8.c
index f527983097c576e1fbcaa2325dd736b8cf1aef35..8b2106d209f6f3c1ce4d5fe9f6d94eac29d3e08d 100644
--- a/libgfortran/generated/maxval_i8.c
+++ b/libgfortran/generated/maxval_i8.c
@@ -116,8 +116,9 @@ maxval_i8 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ maxval_i8 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ smaxval_i8 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxval_r10.c b/libgfortran/generated/maxval_r10.c
index fd775c0e4d5a66f796e64eab79ca94a732f887c8..a076190e8af70b0e54a901d376381729455e6a8e 100644
--- a/libgfortran/generated/maxval_r10.c
+++ b/libgfortran/generated/maxval_r10.c
@@ -116,8 +116,9 @@ maxval_r10 (gfc_array_r10 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ maxval_r10 (gfc_array_r10 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ smaxval_r10 (gfc_array_r10 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxval_r16.c b/libgfortran/generated/maxval_r16.c
index 671ce1499f93c86fb8253231758eb1f7696c134e..1e36379048bc3c48d8ae42cabf328743a9534fa6 100644
--- a/libgfortran/generated/maxval_r16.c
+++ b/libgfortran/generated/maxval_r16.c
@@ -116,8 +116,9 @@ maxval_r16 (gfc_array_r16 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ maxval_r16 (gfc_array_r16 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ smaxval_r16 (gfc_array_r16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxval_r4.c b/libgfortran/generated/maxval_r4.c
index 674142274e923edb3ab589a725691d92d992a36f..222a4e3beeec9c7d6708333c1caee57a91411345 100644
--- a/libgfortran/generated/maxval_r4.c
+++ b/libgfortran/generated/maxval_r4.c
@@ -116,8 +116,9 @@ maxval_r4 (gfc_array_r4 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ maxval_r4 (gfc_array_r4 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ smaxval_r4 (gfc_array_r4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/maxval_r8.c b/libgfortran/generated/maxval_r8.c
index 136ef20794c08899621fffe74d857e56b0e0b6f4..163ec5a1b030c47bac2f80c457641d8361c17303 100644
--- a/libgfortran/generated/maxval_r8.c
+++ b/libgfortran/generated/maxval_r8.c
@@ -116,8 +116,9 @@ maxval_r8 (gfc_array_r8 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ maxval_r8 (gfc_array_r8 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ smaxval_r8 (gfc_array_r8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_16_i1.c b/libgfortran/generated/minloc0_16_i1.c
index 9529997a37473010c84784b3b3b8531bc74feaea..d0d6903bf411b7b6a67b4f4dd6a734cb3e617c12 100644
--- a/libgfortran/generated/minloc0_16_i1.c
+++ b/libgfortran/generated/minloc0_16_i1.c
@@ -77,13 +77,13 @@ minloc0_16_i1 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_16_i16.c b/libgfortran/generated/minloc0_16_i16.c
index 667bfd8a3491b994b64e7daca589bbce924eba7a..59c1d0abbf8931516cfe2564c2001d3336117766 100644
--- a/libgfortran/generated/minloc0_16_i16.c
+++ b/libgfortran/generated/minloc0_16_i16.c
@@ -77,13 +77,13 @@ minloc0_16_i16 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_16_i2.c b/libgfortran/generated/minloc0_16_i2.c
index a5c499410bd82b7fed771d8ee3c50eaf285f384b..0df6bd189c5b8c113d9af2166e443d1b70d88a82 100644
--- a/libgfortran/generated/minloc0_16_i2.c
+++ b/libgfortran/generated/minloc0_16_i2.c
@@ -77,13 +77,13 @@ minloc0_16_i2 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_16_i4.c b/libgfortran/generated/minloc0_16_i4.c
index 7c9292cddb36e94cef9d1e928dc5243a1ed3e470..48bb60be73754c8721625fabe181c9e79b04a70b 100644
--- a/libgfortran/generated/minloc0_16_i4.c
+++ b/libgfortran/generated/minloc0_16_i4.c
@@ -77,13 +77,13 @@ minloc0_16_i4 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_16_i8.c b/libgfortran/generated/minloc0_16_i8.c
index 022e49c970786d4552b19a63bfec4b3c75d5cbf3..b92f7e430313b25c9b274895a07be10558acd06a 100644
--- a/libgfortran/generated/minloc0_16_i8.c
+++ b/libgfortran/generated/minloc0_16_i8.c
@@ -77,13 +77,13 @@ minloc0_16_i8 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_16_r10.c b/libgfortran/generated/minloc0_16_r10.c
index a99c5307afcb46ab975b7ad2d471f51324f9660f..6480a8dd681e1edbfed9da165972dc32fcc344f6 100644
--- a/libgfortran/generated/minloc0_16_r10.c
+++ b/libgfortran/generated/minloc0_16_r10.c
@@ -77,13 +77,13 @@ minloc0_16_r10 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_16_r16.c b/libgfortran/generated/minloc0_16_r16.c
index 2b2dcaacb23997ad3f8cda79eb9c18149ae5d00a..325c8f68d509ccf2784380847c297099e8a6a21b 100644
--- a/libgfortran/generated/minloc0_16_r16.c
+++ b/libgfortran/generated/minloc0_16_r16.c
@@ -77,13 +77,13 @@ minloc0_16_r16 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_16_r4.c b/libgfortran/generated/minloc0_16_r4.c
index f265ae4756121b4ba2b37b442d01cc2272e73387..2376d4034b677295d598f5d68bc0c68f28b0e9fc 100644
--- a/libgfortran/generated/minloc0_16_r4.c
+++ b/libgfortran/generated/minloc0_16_r4.c
@@ -77,13 +77,13 @@ minloc0_16_r4 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_16_r8.c b/libgfortran/generated/minloc0_16_r8.c
index 59429f22ee92cf2997da24a555c646a04650fbf7..e72abab2c5bd61402b5e2065804aeec601b5185e 100644
--- a/libgfortran/generated/minloc0_16_r8.c
+++ b/libgfortran/generated/minloc0_16_r8.c
@@ -77,13 +77,13 @@ minloc0_16_r8 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_4_i1.c b/libgfortran/generated/minloc0_4_i1.c
index 24463ead318dade37aace4eb638ac930e4e7c918..ce045a28e731be1649bd48d8517f12ae2b6cb5b1 100644
--- a/libgfortran/generated/minloc0_4_i1.c
+++ b/libgfortran/generated/minloc0_4_i1.c
@@ -77,13 +77,13 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_4_i16.c b/libgfortran/generated/minloc0_4_i16.c
index ddcbc60eab96887ba97cf30052efc78023f13e37..9ae856e686c3afdcb3f0b2f8527661e0295ec640 100644
--- a/libgfortran/generated/minloc0_4_i16.c
+++ b/libgfortran/generated/minloc0_4_i16.c
@@ -77,13 +77,13 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_4_i2.c b/libgfortran/generated/minloc0_4_i2.c
index 60b2c3fcb5799cfee68329511a6841b316eecefc..c33e99cfedba2941afb146da028499ccc353ca85 100644
--- a/libgfortran/generated/minloc0_4_i2.c
+++ b/libgfortran/generated/minloc0_4_i2.c
@@ -77,13 +77,13 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_4_i4.c b/libgfortran/generated/minloc0_4_i4.c
index 6431f38ba5916ad4d0d7169d8599a8bbd2849872..9d7eda6c8394927cf96893fea8a846db30fad0b2 100644
--- a/libgfortran/generated/minloc0_4_i4.c
+++ b/libgfortran/generated/minloc0_4_i4.c
@@ -77,13 +77,13 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_4_i8.c b/libgfortran/generated/minloc0_4_i8.c
index 6ffeac577fc68d5f18c570bf927c6c297c43ccec..046e040daf0b6f8aa64e1b5aa0c129abdfc695d3 100644
--- a/libgfortran/generated/minloc0_4_i8.c
+++ b/libgfortran/generated/minloc0_4_i8.c
@@ -77,13 +77,13 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_4_r10.c b/libgfortran/generated/minloc0_4_r10.c
index e4f10024c50ed1656127db5a9d02cc455e3c6de6..8f7b92478686e36a9bb38e3fee526dda0c909b1c 100644
--- a/libgfortran/generated/minloc0_4_r10.c
+++ b/libgfortran/generated/minloc0_4_r10.c
@@ -77,13 +77,13 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_4_r16.c b/libgfortran/generated/minloc0_4_r16.c
index 0f9fb9804679af61242dfd164fa847266c030e63..1539192ca158e064315505e25cfebe4e3eb2a425 100644
--- a/libgfortran/generated/minloc0_4_r16.c
+++ b/libgfortran/generated/minloc0_4_r16.c
@@ -77,13 +77,13 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_4_r4.c b/libgfortran/generated/minloc0_4_r4.c
index 14c63b35e133297b45e7acc9568ff386adf4a232..86ffdb8c6efcbd989481429cbb02a3f4ee3c411f 100644
--- a/libgfortran/generated/minloc0_4_r4.c
+++ b/libgfortran/generated/minloc0_4_r4.c
@@ -77,13 +77,13 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_4_r8.c b/libgfortran/generated/minloc0_4_r8.c
index 168d0ad26211a721bb39d426cde9ea4a52b43a6b..e78cdd898f522eae8187ba98dcdd1c4c514d342f 100644
--- a/libgfortran/generated/minloc0_4_r8.c
+++ b/libgfortran/generated/minloc0_4_r8.c
@@ -77,13 +77,13 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_8_i1.c b/libgfortran/generated/minloc0_8_i1.c
index 6dcafbae05de187159bc7b3aa290aab86dfefe5b..5872d85560dba1edec62f199cd12cf24a2bb9dcb 100644
--- a/libgfortran/generated/minloc0_8_i1.c
+++ b/libgfortran/generated/minloc0_8_i1.c
@@ -77,13 +77,13 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_8_i16.c b/libgfortran/generated/minloc0_8_i16.c
index f2afae1e643f968915ef080a1a6cf46ba552f90e..b56409a050c77a7542208f3823e0b3e7065abc5d 100644
--- a/libgfortran/generated/minloc0_8_i16.c
+++ b/libgfortran/generated/minloc0_8_i16.c
@@ -77,13 +77,13 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_8_i2.c b/libgfortran/generated/minloc0_8_i2.c
index d0dd13744276de4ef46fc7ce5192b784bf7b80dc..63cd947c42d57ac7a85082d86d233319573db46c 100644
--- a/libgfortran/generated/minloc0_8_i2.c
+++ b/libgfortran/generated/minloc0_8_i2.c
@@ -77,13 +77,13 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_8_i4.c b/libgfortran/generated/minloc0_8_i4.c
index a4c921acfe3f84217e09b71c9ce142ef28a884bb..5092f89f7062fd52ab294f9b95fd7351fbde25e2 100644
--- a/libgfortran/generated/minloc0_8_i4.c
+++ b/libgfortran/generated/minloc0_8_i4.c
@@ -77,13 +77,13 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_8_i8.c b/libgfortran/generated/minloc0_8_i8.c
index 26aa9476cf44b7a52355474471722d846e4848e2..e1b99ef9f9402d01d3b0cd40d84f0c133fa4fc8b 100644
--- a/libgfortran/generated/minloc0_8_i8.c
+++ b/libgfortran/generated/minloc0_8_i8.c
@@ -77,13 +77,13 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_8_r10.c b/libgfortran/generated/minloc0_8_r10.c
index b1705ebc5fd8a11a3a849104b16f855edd2dd0c3..600b3aa6af050d45c4160592c128a9c9d96afce5 100644
--- a/libgfortran/generated/minloc0_8_r10.c
+++ b/libgfortran/generated/minloc0_8_r10.c
@@ -77,13 +77,13 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_8_r16.c b/libgfortran/generated/minloc0_8_r16.c
index 84b95baa6a597d2122cf925391a8acd5bca098e4..fa4b5cd1d560fae7efdd5a6a1b515b9a70926fcd 100644
--- a/libgfortran/generated/minloc0_8_r16.c
+++ b/libgfortran/generated/minloc0_8_r16.c
@@ -77,13 +77,13 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_8_r4.c b/libgfortran/generated/minloc0_8_r4.c
index d7b8d547ecec184deaff58c837e149c0696796c0..1347f15c8a88d047bcc14ce3b3b98c1ba004a1ae 100644
--- a/libgfortran/generated/minloc0_8_r4.c
+++ b/libgfortran/generated/minloc0_8_r4.c
@@ -77,13 +77,13 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc0_8_r8.c b/libgfortran/generated/minloc0_8_r8.c
index 6ac0bfe1b00eaaff216c68b1c16b00e3d350202d..6a7b2f0d6b01c464c68ded8e75cb817559d0dfc9 100644
--- a/libgfortran/generated/minloc0_8_r8.c
+++ b/libgfortran/generated/minloc0_8_r8.c
@@ -77,13 +77,13 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -203,18 +203,19 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
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++)
{
@@ -222,8 +223,8 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -360,7 +361,7 @@ sminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_16_i1.c b/libgfortran/generated/minloc1_16_i1.c
index c1baf547b4b854607249022de8f6f629e81b327e..f4abfa8f0d1e3f2330944cd2741e1fbcbf13372a 100644
--- a/libgfortran/generated/minloc1_16_i1.c
+++ b/libgfortran/generated/minloc1_16_i1.c
@@ -117,8 +117,9 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_16_i16.c b/libgfortran/generated/minloc1_16_i16.c
index db992cb4a7cfcd4e15caa893089245f3f38f1743..40b86eadc6c90aabda58ad44b7261aafd7a34919 100644
--- a/libgfortran/generated/minloc1_16_i16.c
+++ b/libgfortran/generated/minloc1_16_i16.c
@@ -117,8 +117,9 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_16_i2.c b/libgfortran/generated/minloc1_16_i2.c
index 523a4affff4fe55aa4278c3fccc50e7e64d82bfe..f7057b2c849bc257cb21fcaa1bc206ad232c6318 100644
--- a/libgfortran/generated/minloc1_16_i2.c
+++ b/libgfortran/generated/minloc1_16_i2.c
@@ -117,8 +117,9 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_16_i4.c b/libgfortran/generated/minloc1_16_i4.c
index e8d5fc397c6e5a62699edf8cd63378f2dd5c1891..3cf6f0de83fa14f82e1a6eac3daa88e5164dbc5c 100644
--- a/libgfortran/generated/minloc1_16_i4.c
+++ b/libgfortran/generated/minloc1_16_i4.c
@@ -117,8 +117,9 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_16_i8.c b/libgfortran/generated/minloc1_16_i8.c
index 8c3e4e482426e6c12a6b6156ebca9c86e276a671..a0838687ba88ec9328de1be7b8a69de855a835c4 100644
--- a/libgfortran/generated/minloc1_16_i8.c
+++ b/libgfortran/generated/minloc1_16_i8.c
@@ -117,8 +117,9 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_16_r10.c b/libgfortran/generated/minloc1_16_r10.c
index 7aa89a947ccc0de945dd4bb590d3674b6925bd4e..20b1c5789a7d3a573c1b4c7f5c0e5b8c7b842a22 100644
--- a/libgfortran/generated/minloc1_16_r10.c
+++ b/libgfortran/generated/minloc1_16_r10.c
@@ -117,8 +117,9 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_16_r16.c b/libgfortran/generated/minloc1_16_r16.c
index 5b814451d6001ff6f156ae1977a360ebe98dee4f..40fcbaea3f95c44dc79606ee67e9add1d12709d3 100644
--- a/libgfortran/generated/minloc1_16_r16.c
+++ b/libgfortran/generated/minloc1_16_r16.c
@@ -117,8 +117,9 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_16_r4.c b/libgfortran/generated/minloc1_16_r4.c
index b3c61552ffedc9a368380d5f27e705a1368ad182..76e7efaf0eba7ffb8d1aba46666278eae263130b 100644
--- a/libgfortran/generated/minloc1_16_r4.c
+++ b/libgfortran/generated/minloc1_16_r4.c
@@ -117,8 +117,9 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_16_r8.c b/libgfortran/generated/minloc1_16_r8.c
index 0a4b1b507776aa8019f1b7bd8e8d00848f276321..97ca8661dfbbc3f04af146c6d9e1e832a5c34141 100644
--- a/libgfortran/generated/minloc1_16_r8.c
+++ b/libgfortran/generated/minloc1_16_r8.c
@@ -117,8 +117,9 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_4_i1.c b/libgfortran/generated/minloc1_4_i1.c
index 9cebebe10a033929b5fb2bd91e521023cbf0987c..330c0d9b91a1928a1080392c4e8402d6c7d880b2 100644
--- a/libgfortran/generated/minloc1_4_i1.c
+++ b/libgfortran/generated/minloc1_4_i1.c
@@ -117,8 +117,9 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_4_i16.c b/libgfortran/generated/minloc1_4_i16.c
index a984a153d380c71b2eddbc624bf1da2f35dd2f5d..a142adb9630aa18dfda8a1dd810c84cbd5708cf4 100644
--- a/libgfortran/generated/minloc1_4_i16.c
+++ b/libgfortran/generated/minloc1_4_i16.c
@@ -117,8 +117,9 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_4_i2.c b/libgfortran/generated/minloc1_4_i2.c
index 685f9793b73feef33600f03dbef0eb132e5ea34b..d7a92804094c2df7635022eee8fd5c342d9b6fc3 100644
--- a/libgfortran/generated/minloc1_4_i2.c
+++ b/libgfortran/generated/minloc1_4_i2.c
@@ -117,8 +117,9 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_4_i4.c b/libgfortran/generated/minloc1_4_i4.c
index f44a631d352bf3ce5cc88654c43e8dc39361bb57..c6b12e84e2614ad103bbb19937b9088cc8d6140c 100644
--- a/libgfortran/generated/minloc1_4_i4.c
+++ b/libgfortran/generated/minloc1_4_i4.c
@@ -117,8 +117,9 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_4_i8.c b/libgfortran/generated/minloc1_4_i8.c
index f6858c028205368bbe11eb31de1b5696da01dd58..bac4eb5fc8216309e73573968840636083012634 100644
--- a/libgfortran/generated/minloc1_4_i8.c
+++ b/libgfortran/generated/minloc1_4_i8.c
@@ -117,8 +117,9 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_4_r10.c b/libgfortran/generated/minloc1_4_r10.c
index 8e359fe15193427d1715b1124402c37ffe805622..0579519ab0deee9199666c169d4b6d5d943af3fa 100644
--- a/libgfortran/generated/minloc1_4_r10.c
+++ b/libgfortran/generated/minloc1_4_r10.c
@@ -117,8 +117,9 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_4_r16.c b/libgfortran/generated/minloc1_4_r16.c
index 11cb9c8f96271de741b8ab9523f707d7cb00dbd3..d74d26dc605737dd38268d887b14cb2c03680cd9 100644
--- a/libgfortran/generated/minloc1_4_r16.c
+++ b/libgfortran/generated/minloc1_4_r16.c
@@ -117,8 +117,9 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_4_r4.c b/libgfortran/generated/minloc1_4_r4.c
index 31aa1f7a621046ce49acc4526cebbd9cd58371f4..050ed5c3c793b0f2d8e80da031d2caecbcbb30bd 100644
--- a/libgfortran/generated/minloc1_4_r4.c
+++ b/libgfortran/generated/minloc1_4_r4.c
@@ -117,8 +117,9 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_4_r8.c b/libgfortran/generated/minloc1_4_r8.c
index a7a56b67f897f58e74ca039eee377a4db3e58bc3..483cd19f2629332b81f549a35a4c6cff5cf4ee20 100644
--- a/libgfortran/generated/minloc1_4_r8.c
+++ b/libgfortran/generated/minloc1_4_r8.c
@@ -117,8 +117,9 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_8_i1.c b/libgfortran/generated/minloc1_8_i1.c
index 1fae32b3fb6654ba13e62315fc093152a48de197..1fc81d106e20d2335d3a869cc538ad8c518e331d 100644
--- a/libgfortran/generated/minloc1_8_i1.c
+++ b/libgfortran/generated/minloc1_8_i1.c
@@ -117,8 +117,9 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_8_i16.c b/libgfortran/generated/minloc1_8_i16.c
index 0d31c944b851f871bc2c9523630e45073ed25a61..ecbabc7a9818b11a177e3bba6fb17ad22735478d 100644
--- a/libgfortran/generated/minloc1_8_i16.c
+++ b/libgfortran/generated/minloc1_8_i16.c
@@ -117,8 +117,9 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_8_i2.c b/libgfortran/generated/minloc1_8_i2.c
index 88655757ddc05387362abbc88ffb0e63f8e82784..2c03443258e23761fd4dc2358c89763feffe60f7 100644
--- a/libgfortran/generated/minloc1_8_i2.c
+++ b/libgfortran/generated/minloc1_8_i2.c
@@ -117,8 +117,9 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_8_i4.c b/libgfortran/generated/minloc1_8_i4.c
index 31ee2385b36d8ea21d6d58108accbd322512bc6f..945423748c5c5f1b3623ca79364dee0088ccc14a 100644
--- a/libgfortran/generated/minloc1_8_i4.c
+++ b/libgfortran/generated/minloc1_8_i4.c
@@ -117,8 +117,9 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_8_i8.c b/libgfortran/generated/minloc1_8_i8.c
index 13577aba741ed02ee4554ccbc8834282d3775e8c..df801458e09ab0e396ab964b86095f31b11e97aa 100644
--- a/libgfortran/generated/minloc1_8_i8.c
+++ b/libgfortran/generated/minloc1_8_i8.c
@@ -117,8 +117,9 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_8_r10.c b/libgfortran/generated/minloc1_8_r10.c
index 726aa1c89370bc475db2eb5271596b3b13ebeba6..364bf5c6f04f77892d60228bab12ebe4d53bec90 100644
--- a/libgfortran/generated/minloc1_8_r10.c
+++ b/libgfortran/generated/minloc1_8_r10.c
@@ -117,8 +117,9 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_8_r16.c b/libgfortran/generated/minloc1_8_r16.c
index aaf9797856db193531fd4e393e7f4502d0df051a..b8ad0950ec5eb6af59dbb26cebd4aefccfc3817e 100644
--- a/libgfortran/generated/minloc1_8_r16.c
+++ b/libgfortran/generated/minloc1_8_r16.c
@@ -117,8 +117,9 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_8_r4.c b/libgfortran/generated/minloc1_8_r4.c
index 6b0bcec629cff65ad91daabb04478404855d62c0..e9df66c669f703bbfafb0ab367507c902c52e0a1 100644
--- a/libgfortran/generated/minloc1_8_r4.c
+++ b/libgfortran/generated/minloc1_8_r4.c
@@ -117,8 +117,9 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minloc1_8_r8.c b/libgfortran/generated/minloc1_8_r8.c
index 8a8d266393dfb47abf2e639310edc8f5ead5c286..7d2cfff7fed03cf2627e34760e5ec7a42be1d4a8 100644
--- a/libgfortran/generated/minloc1_8_r8.c
+++ b/libgfortran/generated/minloc1_8_r8.c
@@ -117,8 +117,9 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -130,8 +131,8 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -323,8 +324,8 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -335,8 +336,8 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -460,7 +461,7 @@ sminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minval_i1.c b/libgfortran/generated/minval_i1.c
index ef31ba0c8d8f6f8f1d5377cb991092d6a09bf5fe..1789ec9fcfad0aff7dd22200384c455530efc166 100644
--- a/libgfortran/generated/minval_i1.c
+++ b/libgfortran/generated/minval_i1.c
@@ -116,8 +116,9 @@ minval_i1 (gfc_array_i1 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ minval_i1 (gfc_array_i1 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mminval_i1 (gfc_array_i1 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mminval_i1 (gfc_array_i1 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ sminval_i1 (gfc_array_i1 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minval_i16.c b/libgfortran/generated/minval_i16.c
index 8d7bf50c4aed28451c1946bd4efaa1ead40796a8..2916256e3ebd361a21b4f1938bc9a92c175674e7 100644
--- a/libgfortran/generated/minval_i16.c
+++ b/libgfortran/generated/minval_i16.c
@@ -116,8 +116,9 @@ minval_i16 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ minval_i16 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mminval_i16 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mminval_i16 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ sminval_i16 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minval_i2.c b/libgfortran/generated/minval_i2.c
index c3d63f6482b74b3cd72a771de6acc3cd9e3e50ff..73bf18b61673278ff596d6206acf1a62dd5108f9 100644
--- a/libgfortran/generated/minval_i2.c
+++ b/libgfortran/generated/minval_i2.c
@@ -116,8 +116,9 @@ minval_i2 (gfc_array_i2 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ minval_i2 (gfc_array_i2 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mminval_i2 (gfc_array_i2 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mminval_i2 (gfc_array_i2 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ sminval_i2 (gfc_array_i2 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minval_i4.c b/libgfortran/generated/minval_i4.c
index 48ea446db9cbb82203cfde4940b3c9879c381a30..8d6e52a2ac0cd358f66d5ccb2853898807afc574 100644
--- a/libgfortran/generated/minval_i4.c
+++ b/libgfortran/generated/minval_i4.c
@@ -116,8 +116,9 @@ minval_i4 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ minval_i4 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mminval_i4 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mminval_i4 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ sminval_i4 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minval_i8.c b/libgfortran/generated/minval_i8.c
index cd2100a05ace27b1da9aa35050a27007ac7fa865..22cf462d0605bb0dba0b8574d4eb5c0e5ad21718 100644
--- a/libgfortran/generated/minval_i8.c
+++ b/libgfortran/generated/minval_i8.c
@@ -116,8 +116,9 @@ minval_i8 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ minval_i8 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mminval_i8 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mminval_i8 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ sminval_i8 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minval_r10.c b/libgfortran/generated/minval_r10.c
index 10d0302d4ee1d5e44dd2a6ff62ac6b8f41f4acd5..f4d467c0d992f8fcba563022eefcf2f579960ac6 100644
--- a/libgfortran/generated/minval_r10.c
+++ b/libgfortran/generated/minval_r10.c
@@ -116,8 +116,9 @@ minval_r10 (gfc_array_r10 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ minval_r10 (gfc_array_r10 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mminval_r10 (gfc_array_r10 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mminval_r10 (gfc_array_r10 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ sminval_r10 (gfc_array_r10 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minval_r16.c b/libgfortran/generated/minval_r16.c
index da6e7963a3a1cffb0d0c7d9629bf0c7d4f4288e5..7ba19c99c1bcfb2c7013d6843bbfa771b2213d5c 100644
--- a/libgfortran/generated/minval_r16.c
+++ b/libgfortran/generated/minval_r16.c
@@ -116,8 +116,9 @@ minval_r16 (gfc_array_r16 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ minval_r16 (gfc_array_r16 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mminval_r16 (gfc_array_r16 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mminval_r16 (gfc_array_r16 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ sminval_r16 (gfc_array_r16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minval_r4.c b/libgfortran/generated/minval_r4.c
index 745889a813113ea8fc8235e130f23cae8a343466..3b29f2f5d3b98e7adbf7c2c34e6b2d07c07a034f 100644
--- a/libgfortran/generated/minval_r4.c
+++ b/libgfortran/generated/minval_r4.c
@@ -116,8 +116,9 @@ minval_r4 (gfc_array_r4 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ minval_r4 (gfc_array_r4 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mminval_r4 (gfc_array_r4 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mminval_r4 (gfc_array_r4 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ sminval_r4 (gfc_array_r4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/minval_r8.c b/libgfortran/generated/minval_r8.c
index 1b0fec0174a5f4d650d2629b719deaa169043b07..adca8b28c7d347f064cd3104e6ddcef2151a2f2c 100644
--- a/libgfortran/generated/minval_r8.c
+++ b/libgfortran/generated/minval_r8.c
@@ -116,8 +116,9 @@ minval_r8 (gfc_array_r8 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ minval_r8 (gfc_array_r8 * const restrict retarray,
- 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]);
}
}
@@ -317,8 +318,8 @@ mminval_r8 (gfc_array_r8 * const restrict retarray,
- 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++)
@@ -329,8 +330,8 @@ mminval_r8 (gfc_array_r8 * const restrict retarray,
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);
}
}
@@ -449,7 +450,7 @@ sminval_r8 (gfc_array_r8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/product_c10.c b/libgfortran/generated/product_c10.c
index 701835f9a43ed992419daa3b1edcd6be22ab4d4f..def678ab953eeca8fb477f707d59e632e712c77b 100644
--- a/libgfortran/generated/product_c10.c
+++ b/libgfortran/generated/product_c10.c
@@ -116,8 +116,9 @@ product_c10 (gfc_array_c10 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ product_c10 (gfc_array_c10 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ sproduct_c10 (gfc_array_c10 * const restrict retarray,
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)
diff --git a/libgfortran/generated/product_c16.c b/libgfortran/generated/product_c16.c
index 1d58a7687568947565a01a982845ac26e48a3b6e..d8750aef5b00d606a61174b236db30e761b5bd08 100644
--- a/libgfortran/generated/product_c16.c
+++ b/libgfortran/generated/product_c16.c
@@ -116,8 +116,9 @@ product_c16 (gfc_array_c16 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ product_c16 (gfc_array_c16 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ sproduct_c16 (gfc_array_c16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/product_c4.c b/libgfortran/generated/product_c4.c
index 3754fcb5cae75b1e0b9a5656002f0af62ba1a591..7cac33fc8c63a58c45a7df73abf5045aed1e2789 100644
--- a/libgfortran/generated/product_c4.c
+++ b/libgfortran/generated/product_c4.c
@@ -116,8 +116,9 @@ product_c4 (gfc_array_c4 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ product_c4 (gfc_array_c4 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ sproduct_c4 (gfc_array_c4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/product_c8.c b/libgfortran/generated/product_c8.c
index 6312451b794d5212b14653467b01119b31c29066..e4f0f6bfd303ead4a29febf42f71f98b2fb39993 100644
--- a/libgfortran/generated/product_c8.c
+++ b/libgfortran/generated/product_c8.c
@@ -116,8 +116,9 @@ product_c8 (gfc_array_c8 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ product_c8 (gfc_array_c8 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ sproduct_c8 (gfc_array_c8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/product_i1.c b/libgfortran/generated/product_i1.c
index 7003129a4f7bcf017000e0d5e5d67a72abef16f2..5a428cad202f77eeccb862b42d88b84bb9b00b65 100644
--- a/libgfortran/generated/product_i1.c
+++ b/libgfortran/generated/product_i1.c
@@ -116,8 +116,9 @@ product_i1 (gfc_array_i1 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ product_i1 (gfc_array_i1 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ sproduct_i1 (gfc_array_i1 * const restrict retarray,
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)
diff --git a/libgfortran/generated/product_i16.c b/libgfortran/generated/product_i16.c
index 3c448082195b2bc94725c142f5ad570eecb55946..a1593a4f66a4da1dcdda3879059f781b315b0f2b 100644
--- a/libgfortran/generated/product_i16.c
+++ b/libgfortran/generated/product_i16.c
@@ -116,8 +116,9 @@ product_i16 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ product_i16 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ sproduct_i16 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/product_i2.c b/libgfortran/generated/product_i2.c
index ca57d29dc2078428f09e7ec79e61a7520a644285..16793f89579579663129beed34f660c24333faa8 100644
--- a/libgfortran/generated/product_i2.c
+++ b/libgfortran/generated/product_i2.c
@@ -116,8 +116,9 @@ product_i2 (gfc_array_i2 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ product_i2 (gfc_array_i2 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ sproduct_i2 (gfc_array_i2 * const restrict retarray,
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)
diff --git a/libgfortran/generated/product_i4.c b/libgfortran/generated/product_i4.c
index d31eb6e15989f11bad6c96c0d8387207637d5ba8..cbace913d6af6ad6b6ae2409e8b57ce21aa3c67c 100644
--- a/libgfortran/generated/product_i4.c
+++ b/libgfortran/generated/product_i4.c
@@ -116,8 +116,9 @@ product_i4 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ product_i4 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ sproduct_i4 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/product_i8.c b/libgfortran/generated/product_i8.c
index 8867aaea2fdfc193145628fe998b014e8a2df268..f1fc56718a8110d52a932f346d20ea5ae64585e1 100644
--- a/libgfortran/generated/product_i8.c
+++ b/libgfortran/generated/product_i8.c
@@ -116,8 +116,9 @@ product_i8 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ product_i8 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ sproduct_i8 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/product_r10.c b/libgfortran/generated/product_r10.c
index 235b8a664ddd64ffd6373c08013aeed71b209b03..4b7c5803096a59391a620d74b8e045aa74fa7963 100644
--- a/libgfortran/generated/product_r10.c
+++ b/libgfortran/generated/product_r10.c
@@ -116,8 +116,9 @@ product_r10 (gfc_array_r10 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ product_r10 (gfc_array_r10 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ sproduct_r10 (gfc_array_r10 * const restrict retarray,
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)
diff --git a/libgfortran/generated/product_r16.c b/libgfortran/generated/product_r16.c
index 2f837e303f1ca2494f8575c0e37213a035a3f684..b18155bd73ca9efa3f77e3f2a1f90e1c638c4e5f 100644
--- a/libgfortran/generated/product_r16.c
+++ b/libgfortran/generated/product_r16.c
@@ -116,8 +116,9 @@ product_r16 (gfc_array_r16 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ product_r16 (gfc_array_r16 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ sproduct_r16 (gfc_array_r16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/product_r4.c b/libgfortran/generated/product_r4.c
index 4e6c3d178ef6ed289b77072185ca7759e9823311..754cac2bfb18b5db0e8796f38de03885d1c5f602 100644
--- a/libgfortran/generated/product_r4.c
+++ b/libgfortran/generated/product_r4.c
@@ -116,8 +116,9 @@ product_r4 (gfc_array_r4 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ product_r4 (gfc_array_r4 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ sproduct_r4 (gfc_array_r4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/product_r8.c b/libgfortran/generated/product_r8.c
index 849d404869d2f10e6c6be9f6f8dee155bcbff51a..5f68856a8b024acbac1c725df3b06b06f9227bc3 100644
--- a/libgfortran/generated/product_r8.c
+++ b/libgfortran/generated/product_r8.c
@@ -116,8 +116,9 @@ product_r8 (gfc_array_r8 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ product_r8 (gfc_array_r8 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ sproduct_r8 (gfc_array_r8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/sum_c10.c b/libgfortran/generated/sum_c10.c
index f3da3849808163cdfc91d9273b2ba82e899520bd..e495a0ba49779844da8ab9c062f5e6cc1cc8fc58 100644
--- a/libgfortran/generated/sum_c10.c
+++ b/libgfortran/generated/sum_c10.c
@@ -116,8 +116,9 @@ sum_c10 (gfc_array_c10 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ sum_c10 (gfc_array_c10 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ msum_c10 (gfc_array_c10 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ msum_c10 (gfc_array_c10 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ ssum_c10 (gfc_array_c10 * const restrict retarray,
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)
diff --git a/libgfortran/generated/sum_c16.c b/libgfortran/generated/sum_c16.c
index df79daf313a5d027b0fba0cad126a7c1ccd966f6..c73083a930c25f321e2f05e411c8e430884e6fae 100644
--- a/libgfortran/generated/sum_c16.c
+++ b/libgfortran/generated/sum_c16.c
@@ -116,8 +116,9 @@ sum_c16 (gfc_array_c16 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ sum_c16 (gfc_array_c16 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ msum_c16 (gfc_array_c16 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ msum_c16 (gfc_array_c16 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ ssum_c16 (gfc_array_c16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/sum_c4.c b/libgfortran/generated/sum_c4.c
index 9ef9e8399f7cef72a05fb4a78e03b7daca25a0c6..6f32327ad0b2e3149838e75521b274dc334919a4 100644
--- a/libgfortran/generated/sum_c4.c
+++ b/libgfortran/generated/sum_c4.c
@@ -116,8 +116,9 @@ sum_c4 (gfc_array_c4 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ sum_c4 (gfc_array_c4 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ msum_c4 (gfc_array_c4 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ msum_c4 (gfc_array_c4 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ ssum_c4 (gfc_array_c4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/sum_c8.c b/libgfortran/generated/sum_c8.c
index a7f7392e747598744e9bc5de211d3a14805c27cb..80db1101cfe442a94264458bf6cf4f116a4bb77a 100644
--- a/libgfortran/generated/sum_c8.c
+++ b/libgfortran/generated/sum_c8.c
@@ -116,8 +116,9 @@ sum_c8 (gfc_array_c8 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ sum_c8 (gfc_array_c8 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ msum_c8 (gfc_array_c8 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ msum_c8 (gfc_array_c8 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ ssum_c8 (gfc_array_c8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/sum_i1.c b/libgfortran/generated/sum_i1.c
index 8740fb79b5ee374990af7eb520cf530fba0842c7..c652712d4e7f27ef9743c4783a79a51987162709 100644
--- a/libgfortran/generated/sum_i1.c
+++ b/libgfortran/generated/sum_i1.c
@@ -116,8 +116,9 @@ sum_i1 (gfc_array_i1 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ sum_i1 (gfc_array_i1 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ ssum_i1 (gfc_array_i1 * const restrict retarray,
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)
diff --git a/libgfortran/generated/sum_i16.c b/libgfortran/generated/sum_i16.c
index 6500d178fa4d17c42916ca7080e6f78eb9253aef..43a29a2956f8dbbced815c2e40d5ac8b37378cfe 100644
--- a/libgfortran/generated/sum_i16.c
+++ b/libgfortran/generated/sum_i16.c
@@ -116,8 +116,9 @@ sum_i16 (gfc_array_i16 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ sum_i16 (gfc_array_i16 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ ssum_i16 (gfc_array_i16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/sum_i2.c b/libgfortran/generated/sum_i2.c
index 10202c35ac8a909663dd492dd278fa646dcd60d7..6c6fcc1116a3580be14cf104b9b35aa5ca4e520c 100644
--- a/libgfortran/generated/sum_i2.c
+++ b/libgfortran/generated/sum_i2.c
@@ -116,8 +116,9 @@ sum_i2 (gfc_array_i2 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ sum_i2 (gfc_array_i2 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ ssum_i2 (gfc_array_i2 * const restrict retarray,
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)
diff --git a/libgfortran/generated/sum_i4.c b/libgfortran/generated/sum_i4.c
index 4d0e8a4a963eb0562e2c7484761192b85526fbbc..e28d2c96fdf3bc07d336ee9338612c3f9c8a4d2b 100644
--- a/libgfortran/generated/sum_i4.c
+++ b/libgfortran/generated/sum_i4.c
@@ -116,8 +116,9 @@ sum_i4 (gfc_array_i4 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ sum_i4 (gfc_array_i4 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ ssum_i4 (gfc_array_i4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/sum_i8.c b/libgfortran/generated/sum_i8.c
index 8b280a81e0d1cfce08b4f92d4d2672337543e48f..6e824f1ca56f745aad96c6cfec48e8649ccab1b2 100644
--- a/libgfortran/generated/sum_i8.c
+++ b/libgfortran/generated/sum_i8.c
@@ -116,8 +116,9 @@ sum_i8 (gfc_array_i8 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ sum_i8 (gfc_array_i8 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ ssum_i8 (gfc_array_i8 * const restrict retarray,
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)
diff --git a/libgfortran/generated/sum_r10.c b/libgfortran/generated/sum_r10.c
index 0fd8775f93ca3b30705487baadb5b8a834727703..1ebd1ed542541179aebd45801e52de84cefc7c7a 100644
--- a/libgfortran/generated/sum_r10.c
+++ b/libgfortran/generated/sum_r10.c
@@ -116,8 +116,9 @@ sum_r10 (gfc_array_r10 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ sum_r10 (gfc_array_r10 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ msum_r10 (gfc_array_r10 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ msum_r10 (gfc_array_r10 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ ssum_r10 (gfc_array_r10 * const restrict retarray,
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)
diff --git a/libgfortran/generated/sum_r16.c b/libgfortran/generated/sum_r16.c
index 8903b64d8bcf5ee88a5482feef021d1aef90e8e1..0038983a6b4a537c06b8e60ddd513c00a6d20b87 100644
--- a/libgfortran/generated/sum_r16.c
+++ b/libgfortran/generated/sum_r16.c
@@ -116,8 +116,9 @@ sum_r16 (gfc_array_r16 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ sum_r16 (gfc_array_r16 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ msum_r16 (gfc_array_r16 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ msum_r16 (gfc_array_r16 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ ssum_r16 (gfc_array_r16 * const restrict retarray,
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)
diff --git a/libgfortran/generated/sum_r4.c b/libgfortran/generated/sum_r4.c
index 1d3f2d09008e39525ca98fb586e9c0eb7302639b..1f058dcbda05d09a86a0cea69708d6a6bf8c2fe2 100644
--- a/libgfortran/generated/sum_r4.c
+++ b/libgfortran/generated/sum_r4.c
@@ -116,8 +116,9 @@ sum_r4 (gfc_array_r4 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ sum_r4 (gfc_array_r4 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ msum_r4 (gfc_array_r4 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ msum_r4 (gfc_array_r4 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ ssum_r4 (gfc_array_r4 * const restrict retarray,
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)
diff --git a/libgfortran/generated/sum_r8.c b/libgfortran/generated/sum_r8.c
index d049876d5f2f27a1438141f5db0d933a2d97fee7..82a03bc81f707ffd2f30a30f5f00d46a60427089 100644
--- a/libgfortran/generated/sum_r8.c
+++ b/libgfortran/generated/sum_r8.c
@@ -116,8 +116,9 @@ sum_r8 (gfc_array_r8 * const restrict retarray,
{
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)
{
@@ -129,8 +130,8 @@ sum_r8 (gfc_array_r8 * const restrict retarray,
- 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]);
}
}
@@ -316,8 +317,8 @@ msum_r8 (gfc_array_r8 * const restrict retarray,
- 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++)
@@ -328,8 +329,8 @@ msum_r8 (gfc_array_r8 * const restrict retarray,
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);
}
}
@@ -448,7 +449,7 @@ ssum_r8 (gfc_array_r8 * const restrict retarray,
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)
diff --git a/libgfortran/m4/iforeach.m4 b/libgfortran/m4/iforeach.m4
index a49d33b9311eff0f703b6ea579c842be0aa6463e..071900b03b8e1aee41b91ffd9b56013ada6ef521 100644
--- a/libgfortran/m4/iforeach.m4
+++ b/libgfortran/m4/iforeach.m4
@@ -44,13 +44,13 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
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);
}
}
@@ -162,18 +162,19 @@ void
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++)
{
@@ -181,8 +182,8 @@ void
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);
}
}
@@ -318,7 +319,7 @@ void
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)
diff --git a/libgfortran/m4/ifunction.m4 b/libgfortran/m4/ifunction.m4
index 965fff8acc53cb8beced55b09e024aeba2e985b4..9769e4d2ddb626696e6459f29337382332d32b4e 100644
--- a/libgfortran/m4/ifunction.m4
+++ b/libgfortran/m4/ifunction.m4
@@ -99,8 +99,9 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
{
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)
{
@@ -112,8 +113,8 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
- 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]);
}
}
@@ -299,8 +300,8 @@ void
- 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++)
@@ -311,8 +312,8 @@ void
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);
}
}
@@ -430,7 +431,7 @@ void
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)