+2018-01-15 Thomas Koenig <tkoenig@gcc.gnu.org>
+
+ PR fortran/54613
+ * gfortran.h (gfc_check_f): Rename f4ml to f5ml.
+ (gfc_logical_4_kind): New macro
+ * intrinsic.h (gfc_simplify_minloc): Add a gfc_expr *argument.
+ (gfc_simplify_maxloc): Likewise.
+ (gfc_resolve_maxloc): Likewise.
+ (gfc_resolve_minloc): Likewise.
+ * check.c (gfc_check_minloc_maxloc): Add checking for "back"
+ argument; also raise error if it is used (for now). Add it
+ if it isn't present.
+ * intrinsic.c (add_sym_4ml): Rename to
+ (add_sym_5ml), adjust for extra argument.
+ (add_functions): Add "back" constant. Adjust maxloc and minloc
+ for back argument.
+ * iresolve.c (gfc_resolve_maxloc): Add back argument. If back is
+ not of gfc_logical_4_kind, convert.
+ (gfc_resolve_minloc): Likewise.
+ * simplify.c (gfc_simplify_minloc): Add back argument.
+ (gfc_simplify_maxloc): Likewise.
+ * trans-intinsic.c (gfc_conv_intrinsic_minmaxloc): Rename last
+ argument to %VAL to ensure passing by value.
+ (gfc_conv_intrinsic_function): Call gfc_conv_intrinsic_minmaxloc
+ also for library calls.
+
2018-01-13 Jerry DeLisle <jvdelisle@gcc.gnu.org>
PR fortran/82007
format string or format label is present.
* trans-io.c (get_dtio_proc): Likewise. (transfer_expr): Fix
whitespace.
-
+
2018-01-13 Thomas Koenig <tkoenig@gcc.gnu.org>
PR fortran/83744
DIM MASK
I.e. in the case of minloc(array,mask), mask will be in the second
- position of the argument list and we'll have to fix that up. */
+ position of the argument list and we'll have to fix that up. Also,
+ add the BACK argument if that isn't present. */
bool
gfc_check_minloc_maxloc (gfc_actual_arglist *ap)
{
- gfc_expr *a, *m, *d, *k;
+ gfc_expr *a, *m, *d, *k, *b;
a = ap->expr;
if (!int_or_real_or_char_check_f2003 (a, 0) || !array_check (a, 0))
d = ap->next->expr;
m = ap->next->next->expr;
k = ap->next->next->next->expr;
+ b = ap->next->next->next->next->expr;
+
+ if (b)
+ {
+ if (!type_check (b, 4, BT_LOGICAL) || !scalar_check (b,4))
+ return false;
+
+ /* TODO: Remove this once BACK is actually implemented. */
+ if (b->expr_type != EXPR_CONSTANT || b->value.logical != 0)
+ {
+ gfc_error ("BACK argument to %qs intrinsic not yet "
+ "implemented", gfc_current_intrinsic);
+ return false;
+ }
+ }
+ else
+ {
+ b = gfc_get_logical_expr (gfc_default_logical_kind, NULL, 0);
+ ap->next->next->next->next->expr = b;
+ }
if (m == NULL && d != NULL && d->ts.type == BT_LOGICAL
&& ap->next->name == NULL)
bool (*f1m)(gfc_actual_arglist *);
bool (*f2)(struct gfc_expr *, struct gfc_expr *);
bool (*f3)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
- bool (*f4ml)(gfc_actual_arglist *);
+ bool (*f5ml)(gfc_actual_arglist *);
bool (*f3red)(gfc_actual_arglist *);
bool (*f4)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
struct gfc_expr *);
extern int gfc_numeric_storage_size;
extern int gfc_character_storage_size;
+#define gfc_logical_4_kind 4
+
/* symbol.c */
void gfc_clear_new_implicit (void);
bool gfc_add_new_implicit_range (int, int);
might have to be reordered. */
static void
-add_sym_4ml (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
+add_sym_5ml (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
int kind, int standard,
bool (*check) (gfc_actual_arglist *),
- gfc_expr *(*simplify) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *),
- void (*resolve) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *),
+ gfc_expr *(*simplify) (gfc_expr *, gfc_expr *, gfc_expr *,
+ gfc_expr *, gfc_expr *),
+ void (*resolve) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *,
+ gfc_expr *, gfc_expr *),
const char *a1, bt type1, int kind1, int optional1,
const char *a2, bt type2, int kind2, int optional2,
const char *a3, bt type3, int kind3, int optional3,
- const char *a4, bt type4, int kind4, int optional4)
+ const char *a4, bt type4, int kind4, int optional4,
+ const char *a5, bt type5, int kind5, int optional5)
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
- cf.f4ml = check;
- sf.f4 = simplify;
- rf.f4 = resolve;
+ cf.f5ml = check;
+ sf.f5 = simplify;
+ rf.f5 = resolve;
add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf,
a1, type1, kind1, optional1, INTENT_IN,
a2, type2, kind2, optional2, INTENT_IN,
a3, type3, kind3, optional3, INTENT_IN,
a4, type4, kind4, optional4, INTENT_IN,
+ a5, type5, kind5, optional5, INTENT_IN,
(void *) 0);
}
*num = "number", *tm = "time", *nm = "name", *md = "mode",
*vl = "values", *p1 = "path1", *p2 = "path2", *com = "command",
*ca = "coarray", *sub = "sub", *dist = "distance", *failed="failed",
- *c_ptr_1 = "c_ptr_1", *c_ptr_2 = "c_ptr_2";
+ *c_ptr_1 = "c_ptr_1", *c_ptr_2 = "c_ptr_2", *back = "back";
int di, dr, dd, dl, dc, dz, ii;
make_generic ("maxexponent", GFC_ISYM_MAXEXPONENT, GFC_STD_F95);
- add_sym_4ml ("maxloc", GFC_ISYM_MAXLOC, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
+ add_sym_5ml ("maxloc", GFC_ISYM_MAXLOC, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
gfc_check_minloc_maxloc, gfc_simplify_maxloc, gfc_resolve_maxloc,
ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
- msk, BT_LOGICAL, dl, OPTIONAL, kind, BT_INTEGER, di, OPTIONAL);
+ msk, BT_LOGICAL, dl, OPTIONAL, kind, BT_INTEGER, di, OPTIONAL,
+ back, BT_LOGICAL, dl, OPTIONAL);
make_generic ("maxloc", GFC_ISYM_MAXLOC, GFC_STD_F95);
make_generic ("minexponent", GFC_ISYM_MINEXPONENT, GFC_STD_F95);
- add_sym_4ml ("minloc", GFC_ISYM_MINLOC, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
+ add_sym_5ml ("minloc", GFC_ISYM_MINLOC, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
gfc_check_minloc_maxloc, gfc_simplify_minloc, gfc_resolve_minloc,
ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
- msk, BT_LOGICAL, dl, OPTIONAL, kind, BT_INTEGER, di, OPTIONAL);
-
+ msk, BT_LOGICAL, dl, OPTIONAL, kind, BT_INTEGER, di, OPTIONAL,
+ back, BT_LOGICAL, dl, OPTIONAL);
+
make_generic ("minloc", GFC_ISYM_MINLOC, GFC_STD_F95);
add_sym_3red ("minval", GFC_ISYM_MINVAL, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
if (!do_ts29113_check (specific, *ap))
return false;
- if (specific->check.f4ml == gfc_check_minloc_maxloc)
+ if (specific->check.f5ml == gfc_check_minloc_maxloc)
/* This is special because we might have to reorder the argument list. */
t = gfc_check_minloc_maxloc (*ap);
else if (specific->check.f3red == gfc_check_minval_maxval)
gfc_expr *gfc_simplify_merge (gfc_expr *, gfc_expr *, gfc_expr *);
gfc_expr *gfc_simplify_merge_bits (gfc_expr *, gfc_expr *, gfc_expr *);
gfc_expr *gfc_simplify_min (gfc_expr *);
-gfc_expr *gfc_simplify_minloc (gfc_expr*, gfc_expr *, gfc_expr *, gfc_expr *);
+gfc_expr *gfc_simplify_minloc (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *,
+ gfc_expr *);
gfc_expr *gfc_simplify_minval (gfc_expr *, gfc_expr*, gfc_expr*);
gfc_expr *gfc_simplify_max (gfc_expr *);
-gfc_expr *gfc_simplify_maxloc (gfc_expr*, gfc_expr *, gfc_expr *, gfc_expr *);
+gfc_expr *gfc_simplify_maxloc (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *,
+ gfc_expr *);
gfc_expr *gfc_simplify_maxval (gfc_expr *, gfc_expr*, gfc_expr*);
gfc_expr *gfc_simplify_maxexponent (gfc_expr *);
gfc_expr *gfc_simplify_minexponent (gfc_expr *);
void gfc_resolve_lstat (gfc_expr *, gfc_expr *, gfc_expr *);
void gfc_resolve_matmul (gfc_expr *, gfc_expr *, gfc_expr *);
void gfc_resolve_max (gfc_expr *, gfc_actual_arglist *);
-void gfc_resolve_maxloc (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *);
+void gfc_resolve_maxloc (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *);
void gfc_resolve_maxval (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *);
void gfc_resolve_mclock (gfc_expr *);
void gfc_resolve_mclock8 (gfc_expr *);
void gfc_resolve_merge (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *);
void gfc_resolve_merge_bits (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *);
void gfc_resolve_min (gfc_expr *, gfc_actual_arglist *);
-void gfc_resolve_minloc (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *);
+void gfc_resolve_minloc (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *);
void gfc_resolve_minval (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *);
void gfc_resolve_mod (gfc_expr *, gfc_expr *, gfc_expr *);
void gfc_resolve_modulo (gfc_expr *, gfc_expr *, gfc_expr *);
void
gfc_resolve_maxloc (gfc_expr *f, gfc_expr *array, gfc_expr *dim,
- gfc_expr *mask, gfc_expr *kind)
+ gfc_expr *mask, gfc_expr *kind, gfc_expr *back)
{
const char *name;
int i, j, idim;
ts.kind = fkind;
gfc_convert_type_warn (f, &ts, 2, 0);
}
+
+ if (back->ts.kind != gfc_logical_4_kind)
+ {
+ gfc_typespec ts;
+ gfc_clear_ts (&ts);
+ ts.type = BT_LOGICAL;
+ ts.kind = gfc_logical_4_kind;
+ gfc_convert_type_warn (back, &ts, 2, 0);
+ }
}
void
gfc_resolve_minloc (gfc_expr *f, gfc_expr *array, gfc_expr *dim,
- gfc_expr *mask, gfc_expr *kind)
+ gfc_expr *mask, gfc_expr *kind, gfc_expr *back)
{
const char *name;
int i, j, idim;
ts.kind = fkind;
gfc_convert_type_warn (f, &ts, 2, 0);
}
+
+ if (back->ts.kind != gfc_logical_4_kind)
+ {
+ gfc_typespec ts;
+ gfc_clear_ts (&ts);
+ ts.type = BT_LOGICAL;
+ ts.kind = gfc_logical_4_kind;
+ gfc_convert_type_warn (back, &ts, 2, 0);
+ }
}
}
gfc_expr *
-gfc_simplify_minloc (gfc_expr *array, gfc_expr *dim, gfc_expr *mask, gfc_expr *kind)
+gfc_simplify_minloc (gfc_expr *array, gfc_expr *dim, gfc_expr *mask, gfc_expr *kind,
+ gfc_expr *back ATTRIBUTE_UNUSED)
{
return gfc_simplify_minmaxloc (array, dim, mask, kind, -1);
}
gfc_expr *
-gfc_simplify_maxloc (gfc_expr *array, gfc_expr *dim, gfc_expr *mask, gfc_expr *kind)
+gfc_simplify_maxloc (gfc_expr *array, gfc_expr *dim, gfc_expr *mask, gfc_expr *kind,
+ gfc_expr *back ATTRIBUTE_UNUSED)
{
return gfc_simplify_minmaxloc (array, dim, mask, kind, 1);
}
tree pos;
int n;
+ actual = expr->value.function.actual;
+
+ /* The last argument, BACK, is passed by value. Ensure that
+ by setting its name to %VAL. */
+ for (gfc_actual_arglist *a = actual; a; a = a->next)
+ {
+ if (a->next == NULL)
+ a->name = "%VAL";
+ }
+
if (se->ss)
{
gfc_conv_intrinsic_funcall (se, expr);
return;
}
- actual = expr->value.function.actual;
arrayexpr = actual->expr;
/* Special case for character maxloc. Remove unneeded actual
if (arrayexpr->ts.type == BT_CHARACTER)
{
- gfc_actual_arglist *a2, *a3, *a4;
- a2 = actual->next;
- a3 = a2->next;
- a4 = a3->next;
- a4->next = NULL;
- if (a3->expr == NULL)
- {
- actual->next = NULL;
- gfc_free_actual_arglist (a2);
- }
- else
+ gfc_actual_arglist *a, *b;
+ a = actual;
+ while (a->next)
{
- actual->next = a3; /* dim */
- a3->next = NULL;
- a2->next = a4;
- gfc_free_actual_arglist (a4);
+ b = a->next;
+ if (b->expr == NULL || strcmp (b->name, "dim") == 0)
+ {
+ a->next = b->next;
+ b->next = NULL;
+ gfc_free_actual_arglist (b);
+ }
+ else
+ a = b;
}
gfc_conv_intrinsic_funcall (se, expr);
return;
conv_generic_with_optional_char_arg (se, expr, 1, 3);
break;
+ case GFC_ISYM_MINLOC:
+ gfc_conv_intrinsic_minmaxloc (se, expr, LT_EXPR);
+ break;
+
+ case GFC_ISYM_MAXLOC:
+ gfc_conv_intrinsic_minmaxloc (se, expr, GT_EXPR);
+ break;
+
default:
gfc_conv_intrinsic_funcall (se, expr);
break;
+2018-01-15 Thomas Koenig <tkoenig@gcc.gnu.org>
+
+ PR fortran/54613
+ * gfortran.dg/minmaxloc_9.f90: New test.
+ * gfortran.dg/minmaxloc_10.f90: New test.
+ * gfortran.dg/minmaxloc_11.f90: New test.
+
2018-01-15 H.J. Lu <hongjiu.lu@intel.com>
PR target/83839
--- /dev/null
+! { dg-do run }
+! { dg-additional-options "-fdefault-integer-8" }
+! Check max/minloc with eight-bytes logicals.
+!
+program test
+ implicit none
+ integer :: i(1), j(-1:1), res(1)
+ logical, volatile :: m(3), m2(3)
+ m = (/ .false., .false., .false. /)
+ m2 = (/ .false., .true., .false. /)
+ call check(1, 0, MAXLOC((/ 42, 23, 11 /), DIM=1, MASK=.FALSE.))
+ call check(2, 0, MAXLOC((/ 42, 23, 11 /), DIM=1, MASK=m))
+ call check(3, 2, MAXLOC((/ 42, 23, 11 /), DIM=1, MASK=m2))
+ call check(4, 0, MAXLOC(i(1:0), DIM=1, MASK=.TRUE.))
+ call check(5, 0, MAXLOC(i(1:0), DIM=1, MASK=.FALSE.))
+ call check(6, 0, MAXLOC(i(1:0), DIM=1, MASK=m(1:0)))
+ call check(7, 0, MAXLOC(i(1:0), DIM=1))
+ call check(8, 0, MINLOC((/ 42, 23, 11 /), DIM=1, MASK=.FALSE.))
+ call check(9, 0, MINLOC((/ 42, 23, 11 /), DIM=1, MASK=m))
+ call check(10, 0, MINLOC(i(1:0), DIM=1, MASK=.FALSE.))
+ call check(11,0, MINLOC(i(1:0), DIM=1, MASK=m(1:0)))
+ call check(12,0, MINLOC(i(1:0), DIM=1, MASK=.TRUE.))
+ call check(13,0, MINLOC(i(1:0), DIM=1))
+
+ j = (/ 1, 2, 1 /); call check(14, 2, MAXLOC(j, DIM=1))
+ j = (/ 1, 2, 3 /); call check(15, 3, MAXLOC(j, DIM=1))
+ j = (/ 3, 2, 1 /); call check(16, 1, MAXLOC(j, DIM=1))
+ j = (/ 1, 2, 1 /); call check(17, 1, MINLOC(j, DIM=1))
+ j = (/ 1, 2, 3 /); call check(18, 1, MINLOC(j, DIM=1))
+ j = (/ 3, 2, 1 /); call check(19, 3, MINLOC(j, DIM=1))
+
+ j = (/ 1, 2, 1 /); call check(20, 2, MAXLOC(j, DIM=1,mask=.true.))
+ j = (/ 1, 2, 3 /); call check(21, 3, MAXLOC(j, DIM=1,mask=.true.))
+ j = (/ 3, 2, 1 /); call check(22, 1, MAXLOC(j, DIM=1,mask=.true.))
+ j = (/ 1, 2, 1 /); call check(23, 1, MINLOC(j, DIM=1,mask=.true.))
+ j = (/ 1, 2, 3 /); call check(24, 1, MINLOC(j, DIM=1,mask=.true.))
+ j = (/ 3, 2, 1 /); call check(25, 3, MINLOC(j, DIM=1,mask=.true.))
+
+ j = (/ 1, 2, 1 /); call check(26, 0, MAXLOC(j, DIM=1,mask=.false.))
+ j = (/ 1, 2, 3 /); call check(27, 0, MAXLOC(j, DIM=1,mask=.false.))
+ j = (/ 3, 2, 1 /); call check(28, 0, MAXLOC(j, DIM=1,mask=.false.))
+ j = (/ 1, 2, 1 /); call check(29, 0, MINLOC(j, DIM=1,mask=.false.))
+ j = (/ 1, 2, 3 /); call check(30, 0, MINLOC(j, DIM=1,mask=.false.))
+ j = (/ 3, 2, 1 /); call check(31, 0, MINLOC(j, DIM=1,mask=.false.))
+
+ j = (/ 1, 2, 1 /); call check(32, 0, MAXLOC(j, DIM=1,mask=m))
+ j = (/ 1, 2, 3 /); call check(33, 0, MAXLOC(j, DIM=1,mask=m))
+ j = (/ 3, 2, 1 /); call check(34, 0, MAXLOC(j, DIM=1,mask=m))
+ j = (/ 1, 2, 1 /); call check(35, 0, MINLOC(j, DIM=1,mask=m))
+ j = (/ 1, 2, 3 /); call check(36, 0, MINLOC(j, DIM=1,mask=m))
+ j = (/ 3, 2, 1 /); call check(37, 0, MINLOC(j, DIM=1,mask=m))
+
+ j = (/ 1, 2, 1 /); call check(38, 2, MAXLOC(j, DIM=1,mask=m2))
+ j = (/ 1, 2, 3 /); call check(39, 2, MAXLOC(j, DIM=1,mask=m2))
+ j = (/ 3, 2, 1 /); call check(40, 2, MAXLOC(j, DIM=1,mask=m2))
+ j = (/ 1, 2, 1 /); call check(41, 2, MINLOC(j, DIM=1,mask=m2))
+ j = (/ 1, 2, 3 /); call check(42, 2, MINLOC(j, DIM=1,mask=m2))
+ j = (/ 3, 2, 1 /); call check(43, 2, MINLOC(j, DIM=1,mask=m2))
+
+! Check the library minloc and maxloc
+ res = MAXLOC((/ 42, 23, 11 /), MASK=.FALSE.); call check(44, 0, res(1))
+ res = MAXLOC((/ 42, 23, 11 /), MASK=m); call check(45, 0, res(1))
+ res = MAXLOC((/ 42, 23, 11 /), MASK=m2); call check(46, 2, res(1))
+ res = MAXLOC(i(1:0), MASK=.TRUE.); call check(47, 0, res(1))
+ res = MAXLOC(i(1:0), MASK=.FALSE.); call check(48, 0, res(1))
+ res = MAXLOC(i(1:0), MASK=m(1:0)); call check(49, 0, res(1))
+ res = MAXLOC(i(1:0)); call check(50, 0, res(1))
+ res = MINLOC((/ 42, 23, 11 /), MASK=.FALSE.); call check(51, 0, res(1))
+ res = MINLOC((/ 42, 23, 11 /), MASK=m); call check(52, 0, res(1))
+ res = MINLOC(i(1:0), MASK=.FALSE.); call check(53, 0, res(1))
+ res = MINLOC(i(1:0), MASK=m(1:0)); call check(54,0, res(1))
+ res = MINLOC(i(1:0), MASK=.TRUE.); call check(55,0, res(1))
+ res = MINLOC(i(1:0)); call check(56,0, res(1))
+
+ j = (/ 1, 2, 1 /); res = MAXLOC(j); call check(57, 2, res(1))
+ j = (/ 1, 2, 3 /); res = MAXLOC(j); call check(58, 3, res(1))
+ j = (/ 3, 2, 1 /); res = MAXLOC(j); call check(59, 1, res(1))
+ j = (/ 1, 2, 1 /); res = MINLOC(j); call check(60, 1, res(1))
+ j = (/ 1, 2, 3 /); res = MINLOC(j); call check(61, 1, res(1))
+ j = (/ 3, 2, 1 /); res = MINLOC(j); call check(62, 3, res(1))
+
+ j = (/ 1, 2, 1 /); res = MAXLOC(j,mask=.true.); call check(63, 2, res(1))
+ j = (/ 1, 2, 3 /); res = MAXLOC(j,mask=.true.); call check(65, 3, res(1))
+ j = (/ 3, 2, 1 /); res = MAXLOC(j,mask=.true.); call check(66, 1, res(1))
+ j = (/ 1, 2, 1 /); res = MINLOC(j,mask=.true.); call check(67, 1, res(1))
+ j = (/ 1, 2, 3 /); res = MINLOC(j,mask=.true.); call check(68, 1, res(1))
+ j = (/ 3, 2, 1 /); res = MINLOC(j,mask=.true.); call check(69, 3, res(1))
+
+ j = (/ 1, 2, 1 /); res = MAXLOC(j,mask=.false.); call check(70, 0, res(1))
+ j = (/ 1, 2, 3 /); res = MAXLOC(j,mask=.false.); call check(71, 0, res(1))
+ j = (/ 3, 2, 1 /); res = MAXLOC(j,mask=.false.); call check(72, 0, res(1))
+ j = (/ 1, 2, 1 /); res = MINLOC(j,mask=.false.); call check(73, 0, res(1))
+ j = (/ 1, 2, 3 /); res = MINLOC(j,mask=.false.); call check(74, 0, res(1))
+ j = (/ 3, 2, 1 /); res = MINLOC(j,mask=.false.); call check(75, 0, res(1))
+
+ j = (/ 1, 2, 1 /); res = MAXLOC(j,mask=m); call check(76, 0, res(1))
+ j = (/ 1, 2, 3 /); res = MAXLOC(j,mask=m); call check(77, 0, res(1))
+ j = (/ 3, 2, 1 /); res = MAXLOC(j,mask=m); call check(78, 0, res(1))
+ j = (/ 1, 2, 1 /); res = MINLOC(j,mask=m); call check(79, 0, res(1))
+ j = (/ 1, 2, 3 /); res = MINLOC(j,mask=m); call check(80, 0, res(1))
+ j = (/ 3, 2, 1 /); res = MINLOC(j,mask=m);call check(81, 0, res(1))
+
+ j = (/ 1, 2, 1 /); res = MAXLOC(j,mask=m2); call check(82, 2, res(1))
+ j = (/ 1, 2, 3 /); res = MAXLOC(j,mask=m2); call check(83, 2, res(1))
+ j = (/ 3, 2, 1 /); res = MAXLOC(j,mask=m2); call check(84, 2, res(1))
+ j = (/ 1, 2, 1 /); res = MINLOC(j,mask=m2); call check(85, 2, res(1))
+ j = (/ 1, 2, 3 /); res = MINLOC(j,mask=m2); call check(86, 2, res(1))
+ j = (/ 3, 2, 1 /); res = MINLOC(j,mask=m2); call check(87, 2, res(1))
+
+contains
+subroutine check(n, i,j)
+ integer, value, intent(in) :: i,j,n
+ if(i /= j) then
+ call abort()
+! print *, 'ERROR: Test',n,' expected ',i,' received ', j
+ end if
+end subroutine check
+end program
--- /dev/null
+! { dg-do run }
+program main
+ character(len=3), dimension(2) :: a
+ a(1) = 'aaa'
+ a(2) = 'bbb'
+ if (maxloc(a,dim=1) /= 2) call abort
+ if (minloc(a,dim=1) /= 1) call abort
+
+end program main
--- /dev/null
+! { dg-do compile }
+! Check for a few restrictions on the back argument to
+! minloc and maxloc.
+program main
+ integer, dimension(3) :: a
+ a = [1,2,3]
+ print *,minloc(a,back=42) ! { dg-error "must be LOGICAL" }
+ print *,minloc(a,back=[.true.,.false.]) ! { dg-error "must be a scalar" }
+ print *,maxloc(a,back=42) ! { dg-error "must be LOGICAL" }
+ print *,maxloc(a,back=[.true.,.false.]) ! { dg-error "must be a scalar" }
+end program main
+2018-01-15 Thomas Koenig <tkoenig@gcc.gnu.org>
+
+ PR fortran/54613
+ * m4/iparm.m4: Add back_arg macro if in minloc or maxloc.
+ * m4/iforeach-s.m4: Add optional argument back with back_arg
+ macro. Improve m4 quoting. If HAVE_BACK_ARG is defined, assert
+ that back is non-true.
+ * m4/iforeach.m4: Likewise.
+ * m4/ifunction-s.m4: Likewise.
+ * m4/ifunction.m4: Likewise.
+ * m4/maxloc0.m4: Include assert.h
+ * m4/minloc0.m4: Likewise.
+ * m4/maxloc0s.m4: #define HAVE_BACK_ARG.
+ * m4/minloc0s.m4: Likewise.
+ * m4/maxloc1s.m4: Likewise.
+ * m4/minloc1s.m4: Likewise.
+ * m4/maxloc1.m4: Include assert.h, #define HAVE_BACK_ARG.
+ * m4/minloc1.m4: Likewise.
+ * m4/maxloc2s.m4: Add assert.h, add back_arg, assert that
+ back is non-true.
+ * m4/minloc2s.m4: Likewise.
+ * generated/iall_i1.c: Regenerated.
+ * generated/iall_i16.c: Regenerated.
+ * generated/iall_i2.c: Regenerated.
+ * generated/iall_i4.c: Regenerated.
+ * generated/iall_i8.c: Regenerated.
+ * generated/iany_i1.c: Regenerated.
+ * generated/iany_i16.c: Regenerated.
+ * generated/iany_i2.c: Regenerated.
+ * generated/iany_i4.c: Regenerated.
+ * generated/iany_i8.c: Regenerated.
+ * generated/iparity_i1.c: Regenerated.
+ * generated/iparity_i16.c: Regenerated.
+ * generated/iparity_i2.c: Regenerated.
+ * generated/iparity_i4.c: Regenerated.
+ * generated/iparity_i8.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_16_s1.c: Regenerated.
+ * generated/maxloc0_16_s4.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_4_s1.c: Regenerated.
+ * generated/maxloc0_4_s4.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/maxloc0_8_s1.c: Regenerated.
+ * generated/maxloc0_8_s4.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_16_s1.c: Regenerated.
+ * generated/maxloc1_16_s4.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_4_s1.c: Regenerated.
+ * generated/maxloc1_4_s4.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/maxloc1_8_s1.c: Regenerated.
+ * generated/maxloc1_8_s4.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_16_s1.c: Regenerated.
+ * generated/minloc0_16_s4.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_4_s1.c: Regenerated.
+ * generated/minloc0_4_s4.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/minloc0_8_s1.c: Regenerated.
+ * generated/minloc0_8_s4.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_16_s1.c: Regenerated.
+ * generated/minloc1_16_s4.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_4_s1.c: Regenerated.
+ * generated/minloc1_4_s4.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/minloc1_8_s1.c: Regenerated.
+ * generated/minloc1_8_s4.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/norm2_r10.c: Regenerated.
+ * generated/norm2_r16.c: Regenerated.
+ * generated/norm2_r4.c: Regenerated.
+ * generated/norm2_r8.c: Regenerated.
+ * generated/parity_l1.c: Regenerated.
+ * generated/parity_l16.c: Regenerated.
+ * generated/parity_l2.c: Regenerated.
+ * generated/parity_l4.c: Regenerated.
+ * generated/parity_l8.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.
+
2018-01-14 Jerry DeLisle <jvdelisle@gcc.gnu.org>
PR libgfortran/83811
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ iall_i1 (retarray, array, pdim, back);
+#else
iall_i1 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ iall_i16 (retarray, array, pdim, back);
+#else
iall_i16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ iall_i2 (retarray, array, pdim, back);
+#else
iall_i2 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ iall_i4 (retarray, array, pdim, back);
+#else
iall_i4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ iall_i8 (retarray, array, pdim, back);
+#else
iall_i8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ iany_i1 (retarray, array, pdim, back);
+#else
iany_i1 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ iany_i16 (retarray, array, pdim, back);
+#else
iany_i16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ iany_i2 (retarray, array, pdim, back);
+#else
iany_i2 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ iany_i4 (retarray, array, pdim, back);
+#else
iany_i4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ iany_i8 (retarray, array, pdim, back);
+#else
iany_i8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ iparity_i1 (retarray, array, pdim, back);
+#else
iparity_i1 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ iparity_i16 (retarray, array, pdim, back);
+#else
iparity_i16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ iparity_i2 (retarray, array, pdim, back);
+#else
iparity_i2 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ iparity_i4 (retarray, array, pdim, back);
+#else
iparity_i4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ iparity_i8 (retarray, array, pdim, back);
+#else
iparity_i8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
extern void maxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
- gfc_array_i1 * const restrict array);
+ gfc_array_i1 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_16_i1);
void
maxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
- gfc_array_i1 * const restrict array)
+ gfc_array_i1 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_16_i1 (gfc_array_i16 * const restrict,
- gfc_array_i1 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_16_i1);
void
mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
gfc_array_i1 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_16_i1 (gfc_array_i16 * const restrict,
- gfc_array_i1 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_16_i1);
void
smaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
gfc_array_i1 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_16_i1 (retarray, array);
+ maxloc0_16_i1 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_16)
extern void maxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
- gfc_array_i16 * const restrict array);
+ gfc_array_i16 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_16_i16);
void
maxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
- gfc_array_i16 * const restrict array)
+ gfc_array_i16 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_16_i16 (gfc_array_i16 * const restrict,
- gfc_array_i16 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_16_i16);
void
mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
gfc_array_i16 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_16_i16 (gfc_array_i16 * const restrict,
- gfc_array_i16 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_16_i16);
void
smaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
gfc_array_i16 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_16_i16 (retarray, array);
+ maxloc0_16_i16 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_16)
extern void maxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
- gfc_array_i2 * const restrict array);
+ gfc_array_i2 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_16_i2);
void
maxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
- gfc_array_i2 * const restrict array)
+ gfc_array_i2 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_16_i2 (gfc_array_i16 * const restrict,
- gfc_array_i2 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_16_i2);
void
mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
gfc_array_i2 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_16_i2 (gfc_array_i16 * const restrict,
- gfc_array_i2 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i2 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_16_i2);
void
smaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
gfc_array_i2 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_16_i2 (retarray, array);
+ maxloc0_16_i2 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
extern void maxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
- gfc_array_i4 * const restrict array);
+ gfc_array_i4 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_16_i4);
void
maxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
- gfc_array_i4 * const restrict array)
+ gfc_array_i4 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_16_i4 (gfc_array_i16 * const restrict,
- gfc_array_i4 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_16_i4);
void
mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
gfc_array_i4 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_16_i4 (gfc_array_i16 * const restrict,
- gfc_array_i4 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_16_i4);
void
smaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
gfc_array_i4 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_16_i4 (retarray, array);
+ maxloc0_16_i4 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_16)
extern void maxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
- gfc_array_i8 * const restrict array);
+ gfc_array_i8 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_16_i8);
void
maxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
- gfc_array_i8 * const restrict array)
+ gfc_array_i8 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_16_i8 (gfc_array_i16 * const restrict,
- gfc_array_i8 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_16_i8);
void
mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
gfc_array_i8 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_16_i8 (gfc_array_i16 * const restrict,
- gfc_array_i8 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_16_i8);
void
smaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
gfc_array_i8 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_16_i8 (retarray, array);
+ maxloc0_16_i8 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_16)
extern void maxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
- gfc_array_r10 * const restrict array);
+ gfc_array_r10 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_16_r10);
void
maxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
- gfc_array_r10 * const restrict array)
+ gfc_array_r10 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_16_r10 (gfc_array_i16 * const restrict,
- gfc_array_r10 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_16_r10);
void
mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
gfc_array_r10 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_16_r10 (gfc_array_i16 * const restrict,
- gfc_array_r10 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r10 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_16_r10);
void
smaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
gfc_array_r10 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_16_r10 (retarray, array);
+ maxloc0_16_r10 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_16)
extern void maxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
- gfc_array_r16 * const restrict array);
+ gfc_array_r16 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_16_r16);
void
maxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
- gfc_array_r16 * const restrict array)
+ gfc_array_r16 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_16_r16 (gfc_array_i16 * const restrict,
- gfc_array_r16 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_16_r16);
void
mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
gfc_array_r16 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_16_r16 (gfc_array_i16 * const restrict,
- gfc_array_r16 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_16_r16);
void
smaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
gfc_array_r16 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_16_r16 (retarray, array);
+ maxloc0_16_r16 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_16)
extern void maxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
- gfc_array_r4 * const restrict array);
+ gfc_array_r4 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_16_r4);
void
maxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
- gfc_array_r4 * const restrict array)
+ gfc_array_r4 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_16_r4 (gfc_array_i16 * const restrict,
- gfc_array_r4 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_16_r4);
void
mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
gfc_array_r4 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_16_r4 (gfc_array_i16 * const restrict,
- gfc_array_r4 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_16_r4);
void
smaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
gfc_array_r4 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_16_r4 (retarray, array);
+ maxloc0_16_r4 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_16)
extern void maxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
- gfc_array_r8 * const restrict array);
+ gfc_array_r8 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_16_r8);
void
maxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
- gfc_array_r8 * const restrict array)
+ gfc_array_r8 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_16_r8 (gfc_array_i16 * const restrict,
- gfc_array_r8 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_16_r8);
void
mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
gfc_array_r8 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_16_r8 (gfc_array_i16 * const restrict,
- gfc_array_r8 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_16_r8);
void
smaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
gfc_array_r8 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_16_r8 (retarray, array);
+ maxloc0_16_r8 (retarray, array, back);
return;
}
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
static inline int
compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
{
}
extern void maxloc0_16_s1 (gfc_array_i16 * const restrict retarray,
- gfc_array_s1 * const restrict array, gfc_charlen_type len);
+ gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
export_proto(maxloc0_16_s1);
void
maxloc0_16_s1 (gfc_array_i16 * const restrict retarray,
- gfc_array_s1 * const restrict array, gfc_charlen_type len)
+ gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_16_s1 (gfc_array_i16 * const restrict,
- gfc_array_s1 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+ gfc_array_s1 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(mmaxloc0_16_s1);
void
mmaxloc0_16_s1 (gfc_array_i16 * const restrict retarray,
gfc_array_s1 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_16_s1 (gfc_array_i16 * const restrict,
- gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+ gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(smaxloc0_16_s1);
void
smaxloc0_16_s1 (gfc_array_i16 * const restrict retarray,
gfc_array_s1 * const restrict array,
- GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type rank;
index_type dstride;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc0_16_s1 (retarray, array, back, len);
+#else
maxloc0_16_s1 (retarray, array, len);
+#endif
return;
}
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
static inline int
compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
{
}
extern void maxloc0_16_s4 (gfc_array_i16 * const restrict retarray,
- gfc_array_s4 * const restrict array, gfc_charlen_type len);
+ gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
export_proto(maxloc0_16_s4);
void
maxloc0_16_s4 (gfc_array_i16 * const restrict retarray,
- gfc_array_s4 * const restrict array, gfc_charlen_type len)
+ gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_16_s4 (gfc_array_i16 * const restrict,
- gfc_array_s4 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+ gfc_array_s4 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(mmaxloc0_16_s4);
void
mmaxloc0_16_s4 (gfc_array_i16 * const restrict retarray,
gfc_array_s4 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_16_s4 (gfc_array_i16 * const restrict,
- gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+ gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(smaxloc0_16_s4);
void
smaxloc0_16_s4 (gfc_array_i16 * const restrict retarray,
gfc_array_s4 * const restrict array,
- GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type rank;
index_type dstride;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc0_16_s4 (retarray, array, back, len);
+#else
maxloc0_16_s4 (retarray, array, len);
+#endif
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
extern void maxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
- gfc_array_i1 * const restrict array);
+ gfc_array_i1 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_4_i1);
void
maxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
- gfc_array_i1 * const restrict array)
+ gfc_array_i1 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_4_i1 (gfc_array_i4 * const restrict,
- gfc_array_i1 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_4_i1);
void
mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
gfc_array_i1 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_4_i1 (gfc_array_i4 * const restrict,
- gfc_array_i1 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_4_i1);
void
smaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
gfc_array_i1 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_4_i1 (retarray, array);
+ maxloc0_4_i1 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_4)
extern void maxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
- gfc_array_i16 * const restrict array);
+ gfc_array_i16 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_4_i16);
void
maxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
- gfc_array_i16 * const restrict array)
+ gfc_array_i16 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_4_i16 (gfc_array_i4 * const restrict,
- gfc_array_i16 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_4_i16);
void
mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
gfc_array_i16 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_4_i16 (gfc_array_i4 * const restrict,
- gfc_array_i16 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_4_i16);
void
smaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
gfc_array_i16 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_4_i16 (retarray, array);
+ maxloc0_4_i16 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_4)
extern void maxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
- gfc_array_i2 * const restrict array);
+ gfc_array_i2 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_4_i2);
void
maxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
- gfc_array_i2 * const restrict array)
+ gfc_array_i2 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_4_i2 (gfc_array_i4 * const restrict,
- gfc_array_i2 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_4_i2);
void
mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
gfc_array_i2 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_4_i2 (gfc_array_i4 * const restrict,
- gfc_array_i2 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i2 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_4_i2);
void
smaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
gfc_array_i2 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_4_i2 (retarray, array);
+ maxloc0_4_i2 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
extern void maxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
- gfc_array_i4 * const restrict array);
+ gfc_array_i4 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_4_i4);
void
maxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
- gfc_array_i4 * const restrict array)
+ gfc_array_i4 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_4_i4 (gfc_array_i4 * const restrict,
- gfc_array_i4 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_4_i4);
void
mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
gfc_array_i4 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_4_i4 (gfc_array_i4 * const restrict,
- gfc_array_i4 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_4_i4);
void
smaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
gfc_array_i4 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_4_i4 (retarray, array);
+ maxloc0_4_i4 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_4)
extern void maxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
- gfc_array_i8 * const restrict array);
+ gfc_array_i8 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_4_i8);
void
maxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
- gfc_array_i8 * const restrict array)
+ gfc_array_i8 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_4_i8 (gfc_array_i4 * const restrict,
- gfc_array_i8 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_4_i8);
void
mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
gfc_array_i8 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_4_i8 (gfc_array_i4 * const restrict,
- gfc_array_i8 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_4_i8);
void
smaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
gfc_array_i8 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_4_i8 (retarray, array);
+ maxloc0_4_i8 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_4)
extern void maxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
- gfc_array_r10 * const restrict array);
+ gfc_array_r10 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_4_r10);
void
maxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
- gfc_array_r10 * const restrict array)
+ gfc_array_r10 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_4_r10 (gfc_array_i4 * const restrict,
- gfc_array_r10 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_4_r10);
void
mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
gfc_array_r10 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_4_r10 (gfc_array_i4 * const restrict,
- gfc_array_r10 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r10 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_4_r10);
void
smaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
gfc_array_r10 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_4_r10 (retarray, array);
+ maxloc0_4_r10 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_4)
extern void maxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
- gfc_array_r16 * const restrict array);
+ gfc_array_r16 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_4_r16);
void
maxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
- gfc_array_r16 * const restrict array)
+ gfc_array_r16 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_4_r16 (gfc_array_i4 * const restrict,
- gfc_array_r16 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_4_r16);
void
mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
gfc_array_r16 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_4_r16 (gfc_array_i4 * const restrict,
- gfc_array_r16 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_4_r16);
void
smaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
gfc_array_r16 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_4_r16 (retarray, array);
+ maxloc0_4_r16 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_4)
extern void maxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
- gfc_array_r4 * const restrict array);
+ gfc_array_r4 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_4_r4);
void
maxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
- gfc_array_r4 * const restrict array)
+ gfc_array_r4 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_4_r4 (gfc_array_i4 * const restrict,
- gfc_array_r4 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_4_r4);
void
mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
gfc_array_r4 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_4_r4 (gfc_array_i4 * const restrict,
- gfc_array_r4 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_4_r4);
void
smaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
gfc_array_r4 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_4_r4 (retarray, array);
+ maxloc0_4_r4 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_4)
extern void maxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
- gfc_array_r8 * const restrict array);
+ gfc_array_r8 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_4_r8);
void
maxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
- gfc_array_r8 * const restrict array)
+ gfc_array_r8 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_4_r8 (gfc_array_i4 * const restrict,
- gfc_array_r8 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_4_r8);
void
mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
gfc_array_r8 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_4_r8 (gfc_array_i4 * const restrict,
- gfc_array_r8 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_4_r8);
void
smaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
gfc_array_r8 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_4_r8 (retarray, array);
+ maxloc0_4_r8 (retarray, array, back);
return;
}
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
static inline int
compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
{
}
extern void maxloc0_4_s1 (gfc_array_i4 * const restrict retarray,
- gfc_array_s1 * const restrict array, gfc_charlen_type len);
+ gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
export_proto(maxloc0_4_s1);
void
maxloc0_4_s1 (gfc_array_i4 * const restrict retarray,
- gfc_array_s1 * const restrict array, gfc_charlen_type len)
+ gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_4_s1 (gfc_array_i4 * const restrict,
- gfc_array_s1 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+ gfc_array_s1 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(mmaxloc0_4_s1);
void
mmaxloc0_4_s1 (gfc_array_i4 * const restrict retarray,
gfc_array_s1 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_4_s1 (gfc_array_i4 * const restrict,
- gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+ gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(smaxloc0_4_s1);
void
smaxloc0_4_s1 (gfc_array_i4 * const restrict retarray,
gfc_array_s1 * const restrict array,
- GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type rank;
index_type dstride;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc0_4_s1 (retarray, array, back, len);
+#else
maxloc0_4_s1 (retarray, array, len);
+#endif
return;
}
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
static inline int
compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
{
}
extern void maxloc0_4_s4 (gfc_array_i4 * const restrict retarray,
- gfc_array_s4 * const restrict array, gfc_charlen_type len);
+ gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
export_proto(maxloc0_4_s4);
void
maxloc0_4_s4 (gfc_array_i4 * const restrict retarray,
- gfc_array_s4 * const restrict array, gfc_charlen_type len)
+ gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_4_s4 (gfc_array_i4 * const restrict,
- gfc_array_s4 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+ gfc_array_s4 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(mmaxloc0_4_s4);
void
mmaxloc0_4_s4 (gfc_array_i4 * const restrict retarray,
gfc_array_s4 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_4_s4 (gfc_array_i4 * const restrict,
- gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+ gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(smaxloc0_4_s4);
void
smaxloc0_4_s4 (gfc_array_i4 * const restrict retarray,
gfc_array_s4 * const restrict array,
- GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type rank;
index_type dstride;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc0_4_s4 (retarray, array, back, len);
+#else
maxloc0_4_s4 (retarray, array, len);
+#endif
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
extern void maxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
- gfc_array_i1 * const restrict array);
+ gfc_array_i1 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_8_i1);
void
maxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
- gfc_array_i1 * const restrict array)
+ gfc_array_i1 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_8_i1 (gfc_array_i8 * const restrict,
- gfc_array_i1 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_8_i1);
void
mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
gfc_array_i1 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_8_i1 (gfc_array_i8 * const restrict,
- gfc_array_i1 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_8_i1);
void
smaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
gfc_array_i1 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_8_i1 (retarray, array);
+ maxloc0_8_i1 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_8)
extern void maxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
- gfc_array_i16 * const restrict array);
+ gfc_array_i16 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_8_i16);
void
maxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
- gfc_array_i16 * const restrict array)
+ gfc_array_i16 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_8_i16 (gfc_array_i8 * const restrict,
- gfc_array_i16 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_8_i16);
void
mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
gfc_array_i16 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_8_i16 (gfc_array_i8 * const restrict,
- gfc_array_i16 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_8_i16);
void
smaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
gfc_array_i16 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_8_i16 (retarray, array);
+ maxloc0_8_i16 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_8)
extern void maxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
- gfc_array_i2 * const restrict array);
+ gfc_array_i2 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_8_i2);
void
maxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
- gfc_array_i2 * const restrict array)
+ gfc_array_i2 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_8_i2 (gfc_array_i8 * const restrict,
- gfc_array_i2 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_8_i2);
void
mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
gfc_array_i2 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_8_i2 (gfc_array_i8 * const restrict,
- gfc_array_i2 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i2 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_8_i2);
void
smaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
gfc_array_i2 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_8_i2 (retarray, array);
+ maxloc0_8_i2 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
extern void maxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
- gfc_array_i4 * const restrict array);
+ gfc_array_i4 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_8_i4);
void
maxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
- gfc_array_i4 * const restrict array)
+ gfc_array_i4 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_8_i4 (gfc_array_i8 * const restrict,
- gfc_array_i4 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_8_i4);
void
mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
gfc_array_i4 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_8_i4 (gfc_array_i8 * const restrict,
- gfc_array_i4 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_8_i4);
void
smaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
gfc_array_i4 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_8_i4 (retarray, array);
+ maxloc0_8_i4 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_8)
extern void maxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
- gfc_array_i8 * const restrict array);
+ gfc_array_i8 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_8_i8);
void
maxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
- gfc_array_i8 * const restrict array)
+ gfc_array_i8 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_8_i8 (gfc_array_i8 * const restrict,
- gfc_array_i8 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_8_i8);
void
mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
gfc_array_i8 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_8_i8 (gfc_array_i8 * const restrict,
- gfc_array_i8 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_8_i8);
void
smaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
gfc_array_i8 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_8_i8 (retarray, array);
+ maxloc0_8_i8 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_8)
extern void maxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
- gfc_array_r10 * const restrict array);
+ gfc_array_r10 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_8_r10);
void
maxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
- gfc_array_r10 * const restrict array)
+ gfc_array_r10 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_8_r10 (gfc_array_i8 * const restrict,
- gfc_array_r10 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_8_r10);
void
mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
gfc_array_r10 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_8_r10 (gfc_array_i8 * const restrict,
- gfc_array_r10 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r10 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_8_r10);
void
smaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
gfc_array_r10 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_8_r10 (retarray, array);
+ maxloc0_8_r10 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_8)
extern void maxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
- gfc_array_r16 * const restrict array);
+ gfc_array_r16 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_8_r16);
void
maxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
- gfc_array_r16 * const restrict array)
+ gfc_array_r16 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_8_r16 (gfc_array_i8 * const restrict,
- gfc_array_r16 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_8_r16);
void
mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
gfc_array_r16 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_8_r16 (gfc_array_i8 * const restrict,
- gfc_array_r16 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_8_r16);
void
smaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
gfc_array_r16 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_8_r16 (retarray, array);
+ maxloc0_8_r16 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_8)
extern void maxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
- gfc_array_r4 * const restrict array);
+ gfc_array_r4 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_8_r4);
void
maxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
- gfc_array_r4 * const restrict array)
+ gfc_array_r4 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_8_r4 (gfc_array_i8 * const restrict,
- gfc_array_r4 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_8_r4);
void
mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
gfc_array_r4 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_8_r4 (gfc_array_i8 * const restrict,
- gfc_array_r4 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_8_r4);
void
smaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
gfc_array_r4 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_8_r4 (retarray, array);
+ maxloc0_8_r4 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_8)
extern void maxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
- gfc_array_r8 * const restrict array);
+ gfc_array_r8 * const restrict array, GFC_LOGICAL_4);
export_proto(maxloc0_8_r8);
void
maxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
- gfc_array_r8 * const restrict array)
+ gfc_array_r8 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_8_r8 (gfc_array_i8 * const restrict,
- gfc_array_r8 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mmaxloc0_8_r8);
void
mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
gfc_array_r8 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_8_r8 (gfc_array_i8 * const restrict,
- gfc_array_r8 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(smaxloc0_8_r8);
void
smaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
gfc_array_r8 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- maxloc0_8_r8 (retarray, array);
+ maxloc0_8_r8 (retarray, array, back);
return;
}
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
static inline int
compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
{
}
extern void maxloc0_8_s1 (gfc_array_i8 * const restrict retarray,
- gfc_array_s1 * const restrict array, gfc_charlen_type len);
+ gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
export_proto(maxloc0_8_s1);
void
maxloc0_8_s1 (gfc_array_i8 * const restrict retarray,
- gfc_array_s1 * const restrict array, gfc_charlen_type len)
+ gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_8_s1 (gfc_array_i8 * const restrict,
- gfc_array_s1 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+ gfc_array_s1 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(mmaxloc0_8_s1);
void
mmaxloc0_8_s1 (gfc_array_i8 * const restrict retarray,
gfc_array_s1 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_8_s1 (gfc_array_i8 * const restrict,
- gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+ gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(smaxloc0_8_s1);
void
smaxloc0_8_s1 (gfc_array_i8 * const restrict retarray,
gfc_array_s1 * const restrict array,
- GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type rank;
index_type dstride;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc0_8_s1 (retarray, array, back, len);
+#else
maxloc0_8_s1 (retarray, array, len);
+#endif
return;
}
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
static inline int
compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
{
}
extern void maxloc0_8_s4 (gfc_array_i8 * const restrict retarray,
- gfc_array_s4 * const restrict array, gfc_charlen_type len);
+ gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
export_proto(maxloc0_8_s4);
void
maxloc0_8_s4 (gfc_array_i8 * const restrict retarray,
- gfc_array_s4 * const restrict array, gfc_charlen_type len)
+ gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mmaxloc0_8_s4 (gfc_array_i8 * const restrict,
- gfc_array_s4 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+ gfc_array_s4 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(mmaxloc0_8_s4);
void
mmaxloc0_8_s4 (gfc_array_i8 * const restrict retarray,
gfc_array_s4 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void smaxloc0_8_s4 (gfc_array_i8 * const restrict,
- gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+ gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(smaxloc0_8_s4);
void
smaxloc0_8_s4 (gfc_array_i8 * const restrict retarray,
gfc_array_s4 * const restrict array,
- GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type rank;
index_type dstride;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc0_8_s4 (retarray, array, back, len);
+#else
maxloc0_8_s4 (retarray, array, len);
+#endif
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_16_i1 (gfc_array_i16 * const restrict,
- gfc_array_i1 * const restrict, const index_type * const restrict);
+ gfc_array_i1 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_16_i1);
void
maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
gfc_array_i1 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_16_i1 (gfc_array_i16 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_16_i1);
void
mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
gfc_array_i1 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_16_i1 (gfc_array_i16 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_16_i1);
void
smaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
gfc_array_i1 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_i1 (retarray, array, pdim, back);
+#else
maxloc1_16_i1 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_16_i16 (gfc_array_i16 * const restrict,
- gfc_array_i16 * const restrict, const index_type * const restrict);
+ gfc_array_i16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_16_i16);
void
maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
gfc_array_i16 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_16_i16 (gfc_array_i16 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_16_i16);
void
mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
gfc_array_i16 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_16_i16 (gfc_array_i16 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_16_i16);
void
smaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
gfc_array_i16 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_i16 (retarray, array, pdim, back);
+#else
maxloc1_16_i16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_16_i2 (gfc_array_i16 * const restrict,
- gfc_array_i2 * const restrict, const index_type * const restrict);
+ gfc_array_i2 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_16_i2);
void
maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
gfc_array_i2 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_16_i2 (gfc_array_i16 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_16_i2);
void
mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
gfc_array_i2 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_16_i2 (gfc_array_i16 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_16_i2);
void
smaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
gfc_array_i2 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_i2 (retarray, array, pdim, back);
+#else
maxloc1_16_i2 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_16_i4 (gfc_array_i16 * const restrict,
- gfc_array_i4 * const restrict, const index_type * const restrict);
+ gfc_array_i4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_16_i4);
void
maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
gfc_array_i4 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_16_i4 (gfc_array_i16 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_16_i4);
void
mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
gfc_array_i4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_16_i4 (gfc_array_i16 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_16_i4);
void
smaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
gfc_array_i4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_i4 (retarray, array, pdim, back);
+#else
maxloc1_16_i4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_16_i8 (gfc_array_i16 * const restrict,
- gfc_array_i8 * const restrict, const index_type * const restrict);
+ gfc_array_i8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_16_i8);
void
maxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
gfc_array_i8 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_16_i8 (gfc_array_i16 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_16_i8);
void
mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
gfc_array_i8 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_16_i8 (gfc_array_i16 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_16_i8);
void
smaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
gfc_array_i8 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_i8 (retarray, array, pdim, back);
+#else
maxloc1_16_i8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_16_r10 (gfc_array_i16 * const restrict,
- gfc_array_r10 * const restrict, const index_type * const restrict);
+ gfc_array_r10 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_16_r10);
void
maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
gfc_array_r10 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_16_r10 (gfc_array_i16 * const restrict,
gfc_array_r10 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_16_r10);
void
mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
gfc_array_r10 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_16_r10 (gfc_array_i16 * const restrict,
gfc_array_r10 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_16_r10);
void
smaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
gfc_array_r10 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_r10 (retarray, array, pdim, back);
+#else
maxloc1_16_r10 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_16_r16 (gfc_array_i16 * const restrict,
- gfc_array_r16 * const restrict, const index_type * const restrict);
+ gfc_array_r16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_16_r16);
void
maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
gfc_array_r16 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_16_r16 (gfc_array_i16 * const restrict,
gfc_array_r16 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_16_r16);
void
mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
gfc_array_r16 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_16_r16 (gfc_array_i16 * const restrict,
gfc_array_r16 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_16_r16);
void
smaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
gfc_array_r16 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_r16 (retarray, array, pdim, back);
+#else
maxloc1_16_r16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_16_r4 (gfc_array_i16 * const restrict,
- gfc_array_r4 * const restrict, const index_type * const restrict);
+ gfc_array_r4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_16_r4);
void
maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
gfc_array_r4 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_16_r4 (gfc_array_i16 * const restrict,
gfc_array_r4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_16_r4);
void
mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
gfc_array_r4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_16_r4 (gfc_array_i16 * const restrict,
gfc_array_r4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_16_r4);
void
smaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
gfc_array_r4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_r4 (retarray, array, pdim, back);
+#else
maxloc1_16_r4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_16_r8 (gfc_array_i16 * const restrict,
- gfc_array_r8 * const restrict, const index_type * const restrict);
+ gfc_array_r8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_16_r8);
void
maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
gfc_array_r8 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_16_r8 (gfc_array_i16 * const restrict,
gfc_array_r8 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_16_r8);
void
mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
gfc_array_r8 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_16_r8 (gfc_array_i16 * const restrict,
gfc_array_r8 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_16_r8);
void
smaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
gfc_array_r8 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_r8 (retarray, array, pdim, back);
+#else
maxloc1_16_r8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
#include <string.h>
+#include <assert.h>
static inline int
compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
}
extern void maxloc1_16_s1 (gfc_array_i16 * const restrict,
- gfc_array_s1 * const restrict, const index_type * const restrict,
+ gfc_array_s1 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(maxloc1_16_s1);
void
maxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
gfc_array_s1 * const restrict array,
- const index_type * const restrict pdim, gfc_charlen_type string_len)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_16_s1 (gfc_array_i16 * const restrict,
gfc_array_s1 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict, gfc_charlen_type);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(mmaxloc1_16_s1);
void
mmaxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
gfc_array_s1 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_16_s1 (gfc_array_i16 * const restrict,
gfc_array_s1 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *, gfc_charlen_type);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(smaxloc1_16_s1);
void
smaxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
gfc_array_s1 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+ GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_s1 (retarray, array, pdim, back, string_len);
+#else
maxloc1_16_s1 (retarray, array, pdim, string_len);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
#include <string.h>
+#include <assert.h>
static inline int
compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
}
extern void maxloc1_16_s4 (gfc_array_i16 * const restrict,
- gfc_array_s4 * const restrict, const index_type * const restrict,
+ gfc_array_s4 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(maxloc1_16_s4);
void
maxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
gfc_array_s4 * const restrict array,
- const index_type * const restrict pdim, gfc_charlen_type string_len)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_16_s4 (gfc_array_i16 * const restrict,
gfc_array_s4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict, gfc_charlen_type);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(mmaxloc1_16_s4);
void
mmaxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
gfc_array_s4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_16_s4 (gfc_array_i16 * const restrict,
gfc_array_s4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *, gfc_charlen_type);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(smaxloc1_16_s4);
void
smaxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
gfc_array_s4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+ GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_16_s4 (retarray, array, pdim, back, string_len);
+#else
maxloc1_16_s4 (retarray, array, pdim, string_len);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_4_i1 (gfc_array_i4 * const restrict,
- gfc_array_i1 * const restrict, const index_type * const restrict);
+ gfc_array_i1 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_4_i1);
void
maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
gfc_array_i1 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_4_i1 (gfc_array_i4 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_4_i1);
void
mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
gfc_array_i1 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_4_i1 (gfc_array_i4 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_4_i1);
void
smaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
gfc_array_i1 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_i1 (retarray, array, pdim, back);
+#else
maxloc1_4_i1 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_4_i16 (gfc_array_i4 * const restrict,
- gfc_array_i16 * const restrict, const index_type * const restrict);
+ gfc_array_i16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_4_i16);
void
maxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
gfc_array_i16 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_4_i16 (gfc_array_i4 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_4_i16);
void
mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
gfc_array_i16 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_4_i16 (gfc_array_i4 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_4_i16);
void
smaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
gfc_array_i16 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_i16 (retarray, array, pdim, back);
+#else
maxloc1_4_i16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_4_i2 (gfc_array_i4 * const restrict,
- gfc_array_i2 * const restrict, const index_type * const restrict);
+ gfc_array_i2 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_4_i2);
void
maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
gfc_array_i2 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_4_i2 (gfc_array_i4 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_4_i2);
void
mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
gfc_array_i2 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_4_i2 (gfc_array_i4 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_4_i2);
void
smaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
gfc_array_i2 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_i2 (retarray, array, pdim, back);
+#else
maxloc1_4_i2 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_4_i4 (gfc_array_i4 * const restrict,
- gfc_array_i4 * const restrict, const index_type * const restrict);
+ gfc_array_i4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_4_i4);
void
maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
gfc_array_i4 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_4_i4 (gfc_array_i4 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_4_i4);
void
mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
gfc_array_i4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_4_i4 (gfc_array_i4 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_4_i4);
void
smaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
gfc_array_i4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_i4 (retarray, array, pdim, back);
+#else
maxloc1_4_i4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_4_i8 (gfc_array_i4 * const restrict,
- gfc_array_i8 * const restrict, const index_type * const restrict);
+ gfc_array_i8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_4_i8);
void
maxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
gfc_array_i8 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_4_i8 (gfc_array_i4 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_4_i8);
void
mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
gfc_array_i8 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_4_i8 (gfc_array_i4 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_4_i8);
void
smaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
gfc_array_i8 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_i8 (retarray, array, pdim, back);
+#else
maxloc1_4_i8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_4_r10 (gfc_array_i4 * const restrict,
- gfc_array_r10 * const restrict, const index_type * const restrict);
+ gfc_array_r10 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_4_r10);
void
maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
gfc_array_r10 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_4_r10 (gfc_array_i4 * const restrict,
gfc_array_r10 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_4_r10);
void
mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
gfc_array_r10 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_4_r10 (gfc_array_i4 * const restrict,
gfc_array_r10 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_4_r10);
void
smaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
gfc_array_r10 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_r10 (retarray, array, pdim, back);
+#else
maxloc1_4_r10 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_4_r16 (gfc_array_i4 * const restrict,
- gfc_array_r16 * const restrict, const index_type * const restrict);
+ gfc_array_r16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_4_r16);
void
maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
gfc_array_r16 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_4_r16 (gfc_array_i4 * const restrict,
gfc_array_r16 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_4_r16);
void
mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
gfc_array_r16 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_4_r16 (gfc_array_i4 * const restrict,
gfc_array_r16 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_4_r16);
void
smaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
gfc_array_r16 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_r16 (retarray, array, pdim, back);
+#else
maxloc1_4_r16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_4_r4 (gfc_array_i4 * const restrict,
- gfc_array_r4 * const restrict, const index_type * const restrict);
+ gfc_array_r4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_4_r4);
void
maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
gfc_array_r4 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_4_r4 (gfc_array_i4 * const restrict,
gfc_array_r4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_4_r4);
void
mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
gfc_array_r4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_4_r4 (gfc_array_i4 * const restrict,
gfc_array_r4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_4_r4);
void
smaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
gfc_array_r4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_r4 (retarray, array, pdim, back);
+#else
maxloc1_4_r4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_4_r8 (gfc_array_i4 * const restrict,
- gfc_array_r8 * const restrict, const index_type * const restrict);
+ gfc_array_r8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_4_r8);
void
maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
gfc_array_r8 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_4_r8 (gfc_array_i4 * const restrict,
gfc_array_r8 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_4_r8);
void
mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
gfc_array_r8 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_4_r8 (gfc_array_i4 * const restrict,
gfc_array_r8 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_4_r8);
void
smaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
gfc_array_r8 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_r8 (retarray, array, pdim, back);
+#else
maxloc1_4_r8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
#include <string.h>
+#include <assert.h>
static inline int
compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
}
extern void maxloc1_4_s1 (gfc_array_i4 * const restrict,
- gfc_array_s1 * const restrict, const index_type * const restrict,
+ gfc_array_s1 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(maxloc1_4_s1);
void
maxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
gfc_array_s1 * const restrict array,
- const index_type * const restrict pdim, gfc_charlen_type string_len)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_4_s1 (gfc_array_i4 * const restrict,
gfc_array_s1 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict, gfc_charlen_type);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(mmaxloc1_4_s1);
void
mmaxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
gfc_array_s1 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_4_s1 (gfc_array_i4 * const restrict,
gfc_array_s1 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *, gfc_charlen_type);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(smaxloc1_4_s1);
void
smaxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
gfc_array_s1 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+ GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_s1 (retarray, array, pdim, back, string_len);
+#else
maxloc1_4_s1 (retarray, array, pdim, string_len);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
#include <string.h>
+#include <assert.h>
static inline int
compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
}
extern void maxloc1_4_s4 (gfc_array_i4 * const restrict,
- gfc_array_s4 * const restrict, const index_type * const restrict,
+ gfc_array_s4 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(maxloc1_4_s4);
void
maxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
gfc_array_s4 * const restrict array,
- const index_type * const restrict pdim, gfc_charlen_type string_len)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_4_s4 (gfc_array_i4 * const restrict,
gfc_array_s4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict, gfc_charlen_type);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(mmaxloc1_4_s4);
void
mmaxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
gfc_array_s4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_4_s4 (gfc_array_i4 * const restrict,
gfc_array_s4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *, gfc_charlen_type);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(smaxloc1_4_s4);
void
smaxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
gfc_array_s4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+ GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_4_s4 (retarray, array, pdim, back, string_len);
+#else
maxloc1_4_s4 (retarray, array, pdim, string_len);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_8_i1 (gfc_array_i8 * const restrict,
- gfc_array_i1 * const restrict, const index_type * const restrict);
+ gfc_array_i1 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_8_i1);
void
maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
gfc_array_i1 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_8_i1 (gfc_array_i8 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_8_i1);
void
mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
gfc_array_i1 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_8_i1 (gfc_array_i8 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_8_i1);
void
smaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
gfc_array_i1 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_i1 (retarray, array, pdim, back);
+#else
maxloc1_8_i1 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_8_i16 (gfc_array_i8 * const restrict,
- gfc_array_i16 * const restrict, const index_type * const restrict);
+ gfc_array_i16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_8_i16);
void
maxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
gfc_array_i16 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_8_i16 (gfc_array_i8 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_8_i16);
void
mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
gfc_array_i16 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_8_i16 (gfc_array_i8 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_8_i16);
void
smaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
gfc_array_i16 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_i16 (retarray, array, pdim, back);
+#else
maxloc1_8_i16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_8_i2 (gfc_array_i8 * const restrict,
- gfc_array_i2 * const restrict, const index_type * const restrict);
+ gfc_array_i2 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_8_i2);
void
maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
gfc_array_i2 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_8_i2 (gfc_array_i8 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_8_i2);
void
mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
gfc_array_i2 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_8_i2 (gfc_array_i8 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_8_i2);
void
smaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
gfc_array_i2 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_i2 (retarray, array, pdim, back);
+#else
maxloc1_8_i2 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_8_i4 (gfc_array_i8 * const restrict,
- gfc_array_i4 * const restrict, const index_type * const restrict);
+ gfc_array_i4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_8_i4);
void
maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
gfc_array_i4 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_8_i4 (gfc_array_i8 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_8_i4);
void
mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
gfc_array_i4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_8_i4 (gfc_array_i8 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_8_i4);
void
smaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
gfc_array_i4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_i4 (retarray, array, pdim, back);
+#else
maxloc1_8_i4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_8_i8 (gfc_array_i8 * const restrict,
- gfc_array_i8 * const restrict, const index_type * const restrict);
+ gfc_array_i8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_8_i8);
void
maxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
gfc_array_i8 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_8_i8 (gfc_array_i8 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_8_i8);
void
mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
gfc_array_i8 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_8_i8 (gfc_array_i8 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_8_i8);
void
smaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
gfc_array_i8 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_i8 (retarray, array, pdim, back);
+#else
maxloc1_8_i8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_8_r10 (gfc_array_i8 * const restrict,
- gfc_array_r10 * const restrict, const index_type * const restrict);
+ gfc_array_r10 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_8_r10);
void
maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
gfc_array_r10 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_8_r10 (gfc_array_i8 * const restrict,
gfc_array_r10 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_8_r10);
void
mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
gfc_array_r10 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_8_r10 (gfc_array_i8 * const restrict,
gfc_array_r10 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_8_r10);
void
smaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
gfc_array_r10 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_r10 (retarray, array, pdim, back);
+#else
maxloc1_8_r10 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_8_r16 (gfc_array_i8 * const restrict,
- gfc_array_r16 * const restrict, const index_type * const restrict);
+ gfc_array_r16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_8_r16);
void
maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
gfc_array_r16 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_8_r16 (gfc_array_i8 * const restrict,
gfc_array_r16 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_8_r16);
void
mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
gfc_array_r16 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_8_r16 (gfc_array_i8 * const restrict,
gfc_array_r16 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_8_r16);
void
smaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
gfc_array_r16 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_r16 (retarray, array, pdim, back);
+#else
maxloc1_8_r16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_8_r4 (gfc_array_i8 * const restrict,
- gfc_array_r4 * const restrict, const index_type * const restrict);
+ gfc_array_r4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_8_r4);
void
maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
gfc_array_r4 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_8_r4 (gfc_array_i8 * const restrict,
gfc_array_r4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_8_r4);
void
mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
gfc_array_r4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_8_r4 (gfc_array_i8 * const restrict,
gfc_array_r4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_8_r4);
void
smaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
gfc_array_r4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_r4 (retarray, array, pdim, back);
+#else
maxloc1_8_r4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void maxloc1_8_r8 (gfc_array_i8 * const restrict,
- gfc_array_r8 * const restrict, const index_type * const restrict);
+ gfc_array_r8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(maxloc1_8_r8);
void
maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
gfc_array_r8 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_8_r8 (gfc_array_i8 * const restrict,
gfc_array_r8 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mmaxloc1_8_r8);
void
mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
gfc_array_r8 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_8_r8 (gfc_array_i8 * const restrict,
gfc_array_r8 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(smaxloc1_8_r8);
void
smaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
gfc_array_r8 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_r8 (retarray, array, pdim, back);
+#else
maxloc1_8_r8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
#include <string.h>
+#include <assert.h>
static inline int
compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
}
extern void maxloc1_8_s1 (gfc_array_i8 * const restrict,
- gfc_array_s1 * const restrict, const index_type * const restrict,
+ gfc_array_s1 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(maxloc1_8_s1);
void
maxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
gfc_array_s1 * const restrict array,
- const index_type * const restrict pdim, gfc_charlen_type string_len)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_8_s1 (gfc_array_i8 * const restrict,
gfc_array_s1 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict, gfc_charlen_type);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(mmaxloc1_8_s1);
void
mmaxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
gfc_array_s1 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_8_s1 (gfc_array_i8 * const restrict,
gfc_array_s1 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *, gfc_charlen_type);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(smaxloc1_8_s1);
void
smaxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
gfc_array_s1 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+ GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_s1 (retarray, array, pdim, back, string_len);
+#else
maxloc1_8_s1 (retarray, array, pdim, string_len);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
#include <string.h>
+#include <assert.h>
static inline int
compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
}
extern void maxloc1_8_s4 (gfc_array_i8 * const restrict,
- gfc_array_s4 * const restrict, const index_type * const restrict,
+ gfc_array_s4 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(maxloc1_8_s4);
void
maxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
gfc_array_s4 * const restrict array,
- const index_type * const restrict pdim, gfc_charlen_type string_len)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mmaxloc1_8_s4 (gfc_array_i8 * const restrict,
gfc_array_s4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict, gfc_charlen_type);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(mmaxloc1_8_s4);
void
mmaxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
gfc_array_s4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void smaxloc1_8_s4 (gfc_array_i8 * const restrict,
gfc_array_s4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *, gfc_charlen_type);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(smaxloc1_8_s4);
void
smaxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
gfc_array_s4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+ GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxloc1_8_s4 (retarray, array, pdim, back, string_len);
+#else
maxloc1_8_s4 (retarray, array, pdim, string_len);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
return memcmp_char4 (a, b, n);
}
-extern GFC_INTEGER_16 maxloc2_16_s1 (gfc_array_s1 * const restrict,
+extern GFC_INTEGER_16 maxloc2_16_s1 (gfc_array_s1 * const restrict, GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(maxloc2_16_s1);
GFC_INTEGER_16
-maxloc2_16_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
+maxloc2_16_s1 (gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type ret;
index_type sstride;
const GFC_INTEGER_1 *maxval;
index_type i;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_16 mmaxloc2_16_s1 (gfc_array_s1 * const restrict,
- gfc_array_l1 *const restrict mask, gfc_charlen_type);
+ gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(mmaxloc2_16_s1);
GFC_INTEGER_16
mmaxloc2_16_s1 (gfc_array_s1 * const restrict array,
- gfc_array_l1 * const restrict mask,
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
gfc_charlen_type len)
{
index_type ret;
int mask_kind;
index_type mstride;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_16 smaxloc2_16_s1 (gfc_array_s1 * const restrict,
- GFC_LOGICAL_4 *mask, gfc_charlen_type);
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(smaxloc2_16_s1);
GFC_INTEGER_16
smaxloc2_16_s1 (gfc_array_s1 * const restrict array,
- GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
if (mask)
- return maxloc2_16_s1 (array, len);
+ return maxloc2_16_s1 (array, len, back);
else
return 0;
}
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
return memcmp_char4 (a, b, n);
}
-extern GFC_INTEGER_16 maxloc2_16_s4 (gfc_array_s4 * const restrict,
+extern GFC_INTEGER_16 maxloc2_16_s4 (gfc_array_s4 * const restrict, GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(maxloc2_16_s4);
GFC_INTEGER_16
-maxloc2_16_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
+maxloc2_16_s4 (gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type ret;
index_type sstride;
const GFC_INTEGER_4 *maxval;
index_type i;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_16 mmaxloc2_16_s4 (gfc_array_s4 * const restrict,
- gfc_array_l1 *const restrict mask, gfc_charlen_type);
+ gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(mmaxloc2_16_s4);
GFC_INTEGER_16
mmaxloc2_16_s4 (gfc_array_s4 * const restrict array,
- gfc_array_l1 * const restrict mask,
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
gfc_charlen_type len)
{
index_type ret;
int mask_kind;
index_type mstride;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_16 smaxloc2_16_s4 (gfc_array_s4 * const restrict,
- GFC_LOGICAL_4 *mask, gfc_charlen_type);
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(smaxloc2_16_s4);
GFC_INTEGER_16
smaxloc2_16_s4 (gfc_array_s4 * const restrict array,
- GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
if (mask)
- return maxloc2_16_s4 (array, len);
+ return maxloc2_16_s4 (array, len, back);
else
return 0;
}
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
return memcmp_char4 (a, b, n);
}
-extern GFC_INTEGER_4 maxloc2_4_s1 (gfc_array_s1 * const restrict,
+extern GFC_INTEGER_4 maxloc2_4_s1 (gfc_array_s1 * const restrict, GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(maxloc2_4_s1);
GFC_INTEGER_4
-maxloc2_4_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
+maxloc2_4_s1 (gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type ret;
index_type sstride;
const GFC_INTEGER_1 *maxval;
index_type i;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_4 mmaxloc2_4_s1 (gfc_array_s1 * const restrict,
- gfc_array_l1 *const restrict mask, gfc_charlen_type);
+ gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(mmaxloc2_4_s1);
GFC_INTEGER_4
mmaxloc2_4_s1 (gfc_array_s1 * const restrict array,
- gfc_array_l1 * const restrict mask,
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
gfc_charlen_type len)
{
index_type ret;
int mask_kind;
index_type mstride;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_4 smaxloc2_4_s1 (gfc_array_s1 * const restrict,
- GFC_LOGICAL_4 *mask, gfc_charlen_type);
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(smaxloc2_4_s1);
GFC_INTEGER_4
smaxloc2_4_s1 (gfc_array_s1 * const restrict array,
- GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
if (mask)
- return maxloc2_4_s1 (array, len);
+ return maxloc2_4_s1 (array, len, back);
else
return 0;
}
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
return memcmp_char4 (a, b, n);
}
-extern GFC_INTEGER_4 maxloc2_4_s4 (gfc_array_s4 * const restrict,
+extern GFC_INTEGER_4 maxloc2_4_s4 (gfc_array_s4 * const restrict, GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(maxloc2_4_s4);
GFC_INTEGER_4
-maxloc2_4_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
+maxloc2_4_s4 (gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type ret;
index_type sstride;
const GFC_INTEGER_4 *maxval;
index_type i;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_4 mmaxloc2_4_s4 (gfc_array_s4 * const restrict,
- gfc_array_l1 *const restrict mask, gfc_charlen_type);
+ gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(mmaxloc2_4_s4);
GFC_INTEGER_4
mmaxloc2_4_s4 (gfc_array_s4 * const restrict array,
- gfc_array_l1 * const restrict mask,
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
gfc_charlen_type len)
{
index_type ret;
int mask_kind;
index_type mstride;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_4 smaxloc2_4_s4 (gfc_array_s4 * const restrict,
- GFC_LOGICAL_4 *mask, gfc_charlen_type);
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(smaxloc2_4_s4);
GFC_INTEGER_4
smaxloc2_4_s4 (gfc_array_s4 * const restrict array,
- GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
if (mask)
- return maxloc2_4_s4 (array, len);
+ return maxloc2_4_s4 (array, len, back);
else
return 0;
}
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
return memcmp_char4 (a, b, n);
}
-extern GFC_INTEGER_8 maxloc2_8_s1 (gfc_array_s1 * const restrict,
+extern GFC_INTEGER_8 maxloc2_8_s1 (gfc_array_s1 * const restrict, GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(maxloc2_8_s1);
GFC_INTEGER_8
-maxloc2_8_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
+maxloc2_8_s1 (gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type ret;
index_type sstride;
const GFC_INTEGER_1 *maxval;
index_type i;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_8 mmaxloc2_8_s1 (gfc_array_s1 * const restrict,
- gfc_array_l1 *const restrict mask, gfc_charlen_type);
+ gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(mmaxloc2_8_s1);
GFC_INTEGER_8
mmaxloc2_8_s1 (gfc_array_s1 * const restrict array,
- gfc_array_l1 * const restrict mask,
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
gfc_charlen_type len)
{
index_type ret;
int mask_kind;
index_type mstride;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_8 smaxloc2_8_s1 (gfc_array_s1 * const restrict,
- GFC_LOGICAL_4 *mask, gfc_charlen_type);
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(smaxloc2_8_s1);
GFC_INTEGER_8
smaxloc2_8_s1 (gfc_array_s1 * const restrict array,
- GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
if (mask)
- return maxloc2_8_s1 (array, len);
+ return maxloc2_8_s1 (array, len, back);
else
return 0;
}
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
return memcmp_char4 (a, b, n);
}
-extern GFC_INTEGER_8 maxloc2_8_s4 (gfc_array_s4 * const restrict,
+extern GFC_INTEGER_8 maxloc2_8_s4 (gfc_array_s4 * const restrict, GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(maxloc2_8_s4);
GFC_INTEGER_8
-maxloc2_8_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
+maxloc2_8_s4 (gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type ret;
index_type sstride;
const GFC_INTEGER_4 *maxval;
index_type i;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_8 mmaxloc2_8_s4 (gfc_array_s4 * const restrict,
- gfc_array_l1 *const restrict mask, gfc_charlen_type);
+ gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(mmaxloc2_8_s4);
GFC_INTEGER_8
mmaxloc2_8_s4 (gfc_array_s4 * const restrict array,
- gfc_array_l1 * const restrict mask,
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
gfc_charlen_type len)
{
index_type ret;
int mask_kind;
index_type mstride;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_8 smaxloc2_8_s4 (gfc_array_s4 * const restrict,
- GFC_LOGICAL_4 *mask, gfc_charlen_type);
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(smaxloc2_8_s4);
GFC_INTEGER_8
smaxloc2_8_s4 (gfc_array_s4 * const restrict array,
- GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
if (mask)
- return maxloc2_8_s4 (array, len);
+ return maxloc2_8_s4 (array, len, back);
else
return 0;
}
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxval_i1 (retarray, array, pdim, back);
+#else
maxval_i1 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxval_i16 (retarray, array, pdim, back);
+#else
maxval_i16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxval_i2 (retarray, array, pdim, back);
+#else
maxval_i2 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxval_i4 (retarray, array, pdim, back);
+#else
maxval_i4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxval_i8 (retarray, array, pdim, back);
+#else
maxval_i8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxval_r10 (retarray, array, pdim, back);
+#else
maxval_r10 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxval_r16 (retarray, array, pdim, back);
+#else
maxval_r16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxval_r4 (retarray, array, pdim, back);
+#else
maxval_r4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ maxval_r8 (retarray, array, pdim, back);
+#else
maxval_r8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
extern void minloc0_16_i1 (gfc_array_i16 * const restrict retarray,
- gfc_array_i1 * const restrict array);
+ gfc_array_i1 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_16_i1);
void
minloc0_16_i1 (gfc_array_i16 * const restrict retarray,
- gfc_array_i1 * const restrict array)
+ gfc_array_i1 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_16_i1 (gfc_array_i16 * const restrict,
- gfc_array_i1 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_16_i1);
void
mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
gfc_array_i1 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_16_i1 (gfc_array_i16 * const restrict,
- gfc_array_i1 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_i1);
void
sminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
gfc_array_i1 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_16_i1 (retarray, array);
+ minloc0_16_i1 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_16)
extern void minloc0_16_i16 (gfc_array_i16 * const restrict retarray,
- gfc_array_i16 * const restrict array);
+ gfc_array_i16 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_16_i16);
void
minloc0_16_i16 (gfc_array_i16 * const restrict retarray,
- gfc_array_i16 * const restrict array)
+ gfc_array_i16 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_16_i16 (gfc_array_i16 * const restrict,
- gfc_array_i16 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_16_i16);
void
mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
gfc_array_i16 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_16_i16 (gfc_array_i16 * const restrict,
- gfc_array_i16 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_i16);
void
sminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
gfc_array_i16 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_16_i16 (retarray, array);
+ minloc0_16_i16 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_16)
extern void minloc0_16_i2 (gfc_array_i16 * const restrict retarray,
- gfc_array_i2 * const restrict array);
+ gfc_array_i2 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_16_i2);
void
minloc0_16_i2 (gfc_array_i16 * const restrict retarray,
- gfc_array_i2 * const restrict array)
+ gfc_array_i2 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_16_i2 (gfc_array_i16 * const restrict,
- gfc_array_i2 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_16_i2);
void
mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
gfc_array_i2 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_16_i2 (gfc_array_i16 * const restrict,
- gfc_array_i2 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i2 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_i2);
void
sminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
gfc_array_i2 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_16_i2 (retarray, array);
+ minloc0_16_i2 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
extern void minloc0_16_i4 (gfc_array_i16 * const restrict retarray,
- gfc_array_i4 * const restrict array);
+ gfc_array_i4 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_16_i4);
void
minloc0_16_i4 (gfc_array_i16 * const restrict retarray,
- gfc_array_i4 * const restrict array)
+ gfc_array_i4 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_16_i4 (gfc_array_i16 * const restrict,
- gfc_array_i4 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_16_i4);
void
mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
gfc_array_i4 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_16_i4 (gfc_array_i16 * const restrict,
- gfc_array_i4 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_i4);
void
sminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
gfc_array_i4 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_16_i4 (retarray, array);
+ minloc0_16_i4 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_16)
extern void minloc0_16_i8 (gfc_array_i16 * const restrict retarray,
- gfc_array_i8 * const restrict array);
+ gfc_array_i8 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_16_i8);
void
minloc0_16_i8 (gfc_array_i16 * const restrict retarray,
- gfc_array_i8 * const restrict array)
+ gfc_array_i8 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_16_i8 (gfc_array_i16 * const restrict,
- gfc_array_i8 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_16_i8);
void
mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
gfc_array_i8 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_16_i8 (gfc_array_i16 * const restrict,
- gfc_array_i8 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_i8);
void
sminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
gfc_array_i8 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_16_i8 (retarray, array);
+ minloc0_16_i8 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_16)
extern void minloc0_16_r10 (gfc_array_i16 * const restrict retarray,
- gfc_array_r10 * const restrict array);
+ gfc_array_r10 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_16_r10);
void
minloc0_16_r10 (gfc_array_i16 * const restrict retarray,
- gfc_array_r10 * const restrict array)
+ gfc_array_r10 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_16_r10 (gfc_array_i16 * const restrict,
- gfc_array_r10 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_16_r10);
void
mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
gfc_array_r10 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_16_r10 (gfc_array_i16 * const restrict,
- gfc_array_r10 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r10 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_r10);
void
sminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
gfc_array_r10 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_16_r10 (retarray, array);
+ minloc0_16_r10 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_16)
extern void minloc0_16_r16 (gfc_array_i16 * const restrict retarray,
- gfc_array_r16 * const restrict array);
+ gfc_array_r16 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_16_r16);
void
minloc0_16_r16 (gfc_array_i16 * const restrict retarray,
- gfc_array_r16 * const restrict array)
+ gfc_array_r16 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_16_r16 (gfc_array_i16 * const restrict,
- gfc_array_r16 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_16_r16);
void
mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
gfc_array_r16 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_16_r16 (gfc_array_i16 * const restrict,
- gfc_array_r16 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_r16);
void
sminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
gfc_array_r16 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_16_r16 (retarray, array);
+ minloc0_16_r16 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_16)
extern void minloc0_16_r4 (gfc_array_i16 * const restrict retarray,
- gfc_array_r4 * const restrict array);
+ gfc_array_r4 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_16_r4);
void
minloc0_16_r4 (gfc_array_i16 * const restrict retarray,
- gfc_array_r4 * const restrict array)
+ gfc_array_r4 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_16_r4 (gfc_array_i16 * const restrict,
- gfc_array_r4 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_16_r4);
void
mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
gfc_array_r4 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_16_r4 (gfc_array_i16 * const restrict,
- gfc_array_r4 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_r4);
void
sminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
gfc_array_r4 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_16_r4 (retarray, array);
+ minloc0_16_r4 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_16)
extern void minloc0_16_r8 (gfc_array_i16 * const restrict retarray,
- gfc_array_r8 * const restrict array);
+ gfc_array_r8 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_16_r8);
void
minloc0_16_r8 (gfc_array_i16 * const restrict retarray,
- gfc_array_r8 * const restrict array)
+ gfc_array_r8 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_16_r8 (gfc_array_i16 * const restrict,
- gfc_array_r8 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_16_r8);
void
mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
gfc_array_r8 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_16_r8 (gfc_array_i16 * const restrict,
- gfc_array_r8 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_16_r8);
void
sminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
gfc_array_r8 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_16_r8 (retarray, array);
+ minloc0_16_r8 (retarray, array, back);
return;
}
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
static inline int
compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
{
}
extern void minloc0_16_s1 (gfc_array_i16 * const restrict retarray,
- gfc_array_s1 * const restrict array, gfc_charlen_type len);
+ gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
export_proto(minloc0_16_s1);
void
minloc0_16_s1 (gfc_array_i16 * const restrict retarray,
- gfc_array_s1 * const restrict array, gfc_charlen_type len)
+ gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_16_s1 (gfc_array_i16 * const restrict,
- gfc_array_s1 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+ gfc_array_s1 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(mminloc0_16_s1);
void
mminloc0_16_s1 (gfc_array_i16 * const restrict retarray,
gfc_array_s1 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_16_s1 (gfc_array_i16 * const restrict,
- gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+ gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(sminloc0_16_s1);
void
sminloc0_16_s1 (gfc_array_i16 * const restrict retarray,
gfc_array_s1 * const restrict array,
- GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type rank;
index_type dstride;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc0_16_s1 (retarray, array, back, len);
+#else
minloc0_16_s1 (retarray, array, len);
+#endif
return;
}
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
static inline int
compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
{
}
extern void minloc0_16_s4 (gfc_array_i16 * const restrict retarray,
- gfc_array_s4 * const restrict array, gfc_charlen_type len);
+ gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
export_proto(minloc0_16_s4);
void
minloc0_16_s4 (gfc_array_i16 * const restrict retarray,
- gfc_array_s4 * const restrict array, gfc_charlen_type len)
+ gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_16_s4 (gfc_array_i16 * const restrict,
- gfc_array_s4 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+ gfc_array_s4 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(mminloc0_16_s4);
void
mminloc0_16_s4 (gfc_array_i16 * const restrict retarray,
gfc_array_s4 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_16_s4 (gfc_array_i16 * const restrict,
- gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+ gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(sminloc0_16_s4);
void
sminloc0_16_s4 (gfc_array_i16 * const restrict retarray,
gfc_array_s4 * const restrict array,
- GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type rank;
index_type dstride;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc0_16_s4 (retarray, array, back, len);
+#else
minloc0_16_s4 (retarray, array, len);
+#endif
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
extern void minloc0_4_i1 (gfc_array_i4 * const restrict retarray,
- gfc_array_i1 * const restrict array);
+ gfc_array_i1 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_4_i1);
void
minloc0_4_i1 (gfc_array_i4 * const restrict retarray,
- gfc_array_i1 * const restrict array)
+ gfc_array_i1 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_4_i1 (gfc_array_i4 * const restrict,
- gfc_array_i1 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_4_i1);
void
mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
gfc_array_i1 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_4_i1 (gfc_array_i4 * const restrict,
- gfc_array_i1 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_i1);
void
sminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
gfc_array_i1 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_4_i1 (retarray, array);
+ minloc0_4_i1 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_4)
extern void minloc0_4_i16 (gfc_array_i4 * const restrict retarray,
- gfc_array_i16 * const restrict array);
+ gfc_array_i16 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_4_i16);
void
minloc0_4_i16 (gfc_array_i4 * const restrict retarray,
- gfc_array_i16 * const restrict array)
+ gfc_array_i16 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_4_i16 (gfc_array_i4 * const restrict,
- gfc_array_i16 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_4_i16);
void
mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
gfc_array_i16 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_4_i16 (gfc_array_i4 * const restrict,
- gfc_array_i16 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_i16);
void
sminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
gfc_array_i16 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_4_i16 (retarray, array);
+ minloc0_4_i16 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_4)
extern void minloc0_4_i2 (gfc_array_i4 * const restrict retarray,
- gfc_array_i2 * const restrict array);
+ gfc_array_i2 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_4_i2);
void
minloc0_4_i2 (gfc_array_i4 * const restrict retarray,
- gfc_array_i2 * const restrict array)
+ gfc_array_i2 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_4_i2 (gfc_array_i4 * const restrict,
- gfc_array_i2 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_4_i2);
void
mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
gfc_array_i2 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_4_i2 (gfc_array_i4 * const restrict,
- gfc_array_i2 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i2 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_i2);
void
sminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
gfc_array_i2 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_4_i2 (retarray, array);
+ minloc0_4_i2 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
extern void minloc0_4_i4 (gfc_array_i4 * const restrict retarray,
- gfc_array_i4 * const restrict array);
+ gfc_array_i4 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_4_i4);
void
minloc0_4_i4 (gfc_array_i4 * const restrict retarray,
- gfc_array_i4 * const restrict array)
+ gfc_array_i4 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_4_i4 (gfc_array_i4 * const restrict,
- gfc_array_i4 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_4_i4);
void
mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
gfc_array_i4 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_4_i4 (gfc_array_i4 * const restrict,
- gfc_array_i4 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_i4);
void
sminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
gfc_array_i4 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_4_i4 (retarray, array);
+ minloc0_4_i4 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_4)
extern void minloc0_4_i8 (gfc_array_i4 * const restrict retarray,
- gfc_array_i8 * const restrict array);
+ gfc_array_i8 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_4_i8);
void
minloc0_4_i8 (gfc_array_i4 * const restrict retarray,
- gfc_array_i8 * const restrict array)
+ gfc_array_i8 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_4_i8 (gfc_array_i4 * const restrict,
- gfc_array_i8 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_4_i8);
void
mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
gfc_array_i8 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_4_i8 (gfc_array_i4 * const restrict,
- gfc_array_i8 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_i8);
void
sminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
gfc_array_i8 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_4_i8 (retarray, array);
+ minloc0_4_i8 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_4)
extern void minloc0_4_r10 (gfc_array_i4 * const restrict retarray,
- gfc_array_r10 * const restrict array);
+ gfc_array_r10 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_4_r10);
void
minloc0_4_r10 (gfc_array_i4 * const restrict retarray,
- gfc_array_r10 * const restrict array)
+ gfc_array_r10 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_4_r10 (gfc_array_i4 * const restrict,
- gfc_array_r10 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_4_r10);
void
mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
gfc_array_r10 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_4_r10 (gfc_array_i4 * const restrict,
- gfc_array_r10 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r10 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_r10);
void
sminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
gfc_array_r10 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_4_r10 (retarray, array);
+ minloc0_4_r10 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_4)
extern void minloc0_4_r16 (gfc_array_i4 * const restrict retarray,
- gfc_array_r16 * const restrict array);
+ gfc_array_r16 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_4_r16);
void
minloc0_4_r16 (gfc_array_i4 * const restrict retarray,
- gfc_array_r16 * const restrict array)
+ gfc_array_r16 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_4_r16 (gfc_array_i4 * const restrict,
- gfc_array_r16 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_4_r16);
void
mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
gfc_array_r16 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_4_r16 (gfc_array_i4 * const restrict,
- gfc_array_r16 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_r16);
void
sminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
gfc_array_r16 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_4_r16 (retarray, array);
+ minloc0_4_r16 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_4)
extern void minloc0_4_r4 (gfc_array_i4 * const restrict retarray,
- gfc_array_r4 * const restrict array);
+ gfc_array_r4 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_4_r4);
void
minloc0_4_r4 (gfc_array_i4 * const restrict retarray,
- gfc_array_r4 * const restrict array)
+ gfc_array_r4 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_4_r4 (gfc_array_i4 * const restrict,
- gfc_array_r4 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_4_r4);
void
mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
gfc_array_r4 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_4_r4 (gfc_array_i4 * const restrict,
- gfc_array_r4 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_r4);
void
sminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
gfc_array_r4 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_4_r4 (retarray, array);
+ minloc0_4_r4 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_4)
extern void minloc0_4_r8 (gfc_array_i4 * const restrict retarray,
- gfc_array_r8 * const restrict array);
+ gfc_array_r8 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_4_r8);
void
minloc0_4_r8 (gfc_array_i4 * const restrict retarray,
- gfc_array_r8 * const restrict array)
+ gfc_array_r8 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_4_r8 (gfc_array_i4 * const restrict,
- gfc_array_r8 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_4_r8);
void
mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
gfc_array_r8 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_4_r8 (gfc_array_i4 * const restrict,
- gfc_array_r8 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_4_r8);
void
sminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
gfc_array_r8 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_4_r8 (retarray, array);
+ minloc0_4_r8 (retarray, array, back);
return;
}
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
static inline int
compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
{
}
extern void minloc0_4_s1 (gfc_array_i4 * const restrict retarray,
- gfc_array_s1 * const restrict array, gfc_charlen_type len);
+ gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
export_proto(minloc0_4_s1);
void
minloc0_4_s1 (gfc_array_i4 * const restrict retarray,
- gfc_array_s1 * const restrict array, gfc_charlen_type len)
+ gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_4_s1 (gfc_array_i4 * const restrict,
- gfc_array_s1 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+ gfc_array_s1 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(mminloc0_4_s1);
void
mminloc0_4_s1 (gfc_array_i4 * const restrict retarray,
gfc_array_s1 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_4_s1 (gfc_array_i4 * const restrict,
- gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+ gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(sminloc0_4_s1);
void
sminloc0_4_s1 (gfc_array_i4 * const restrict retarray,
gfc_array_s1 * const restrict array,
- GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type rank;
index_type dstride;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc0_4_s1 (retarray, array, back, len);
+#else
minloc0_4_s1 (retarray, array, len);
+#endif
return;
}
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
static inline int
compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
{
}
extern void minloc0_4_s4 (gfc_array_i4 * const restrict retarray,
- gfc_array_s4 * const restrict array, gfc_charlen_type len);
+ gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
export_proto(minloc0_4_s4);
void
minloc0_4_s4 (gfc_array_i4 * const restrict retarray,
- gfc_array_s4 * const restrict array, gfc_charlen_type len)
+ gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_4_s4 (gfc_array_i4 * const restrict,
- gfc_array_s4 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+ gfc_array_s4 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(mminloc0_4_s4);
void
mminloc0_4_s4 (gfc_array_i4 * const restrict retarray,
gfc_array_s4 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_4_s4 (gfc_array_i4 * const restrict,
- gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+ gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(sminloc0_4_s4);
void
sminloc0_4_s4 (gfc_array_i4 * const restrict retarray,
gfc_array_s4 * const restrict array,
- GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type rank;
index_type dstride;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc0_4_s4 (retarray, array, back, len);
+#else
minloc0_4_s4 (retarray, array, len);
+#endif
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
extern void minloc0_8_i1 (gfc_array_i8 * const restrict retarray,
- gfc_array_i1 * const restrict array);
+ gfc_array_i1 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_8_i1);
void
minloc0_8_i1 (gfc_array_i8 * const restrict retarray,
- gfc_array_i1 * const restrict array)
+ gfc_array_i1 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_8_i1 (gfc_array_i8 * const restrict,
- gfc_array_i1 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i1 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_8_i1);
void
mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
gfc_array_i1 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_8_i1 (gfc_array_i8 * const restrict,
- gfc_array_i1 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_i1);
void
sminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
gfc_array_i1 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_8_i1 (retarray, array);
+ minloc0_8_i1 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_8)
extern void minloc0_8_i16 (gfc_array_i8 * const restrict retarray,
- gfc_array_i16 * const restrict array);
+ gfc_array_i16 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_8_i16);
void
minloc0_8_i16 (gfc_array_i8 * const restrict retarray,
- gfc_array_i16 * const restrict array)
+ gfc_array_i16 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_8_i16 (gfc_array_i8 * const restrict,
- gfc_array_i16 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i16 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_8_i16);
void
mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
gfc_array_i16 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_8_i16 (gfc_array_i8 * const restrict,
- gfc_array_i16 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_i16);
void
sminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
gfc_array_i16 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_8_i16 (retarray, array);
+ minloc0_8_i16 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_8)
extern void minloc0_8_i2 (gfc_array_i8 * const restrict retarray,
- gfc_array_i2 * const restrict array);
+ gfc_array_i2 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_8_i2);
void
minloc0_8_i2 (gfc_array_i8 * const restrict retarray,
- gfc_array_i2 * const restrict array)
+ gfc_array_i2 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_8_i2 (gfc_array_i8 * const restrict,
- gfc_array_i2 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i2 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_8_i2);
void
mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
gfc_array_i2 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_8_i2 (gfc_array_i8 * const restrict,
- gfc_array_i2 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i2 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_i2);
void
sminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
gfc_array_i2 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_8_i2 (retarray, array);
+ minloc0_8_i2 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
extern void minloc0_8_i4 (gfc_array_i8 * const restrict retarray,
- gfc_array_i4 * const restrict array);
+ gfc_array_i4 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_8_i4);
void
minloc0_8_i4 (gfc_array_i8 * const restrict retarray,
- gfc_array_i4 * const restrict array)
+ gfc_array_i4 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_8_i4 (gfc_array_i8 * const restrict,
- gfc_array_i4 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i4 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_8_i4);
void
mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
gfc_array_i4 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_8_i4 (gfc_array_i8 * const restrict,
- gfc_array_i4 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_i4);
void
sminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
gfc_array_i4 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_8_i4 (retarray, array);
+ minloc0_8_i4 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_8)
extern void minloc0_8_i8 (gfc_array_i8 * const restrict retarray,
- gfc_array_i8 * const restrict array);
+ gfc_array_i8 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_8_i8);
void
minloc0_8_i8 (gfc_array_i8 * const restrict retarray,
- gfc_array_i8 * const restrict array)
+ gfc_array_i8 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_8_i8 (gfc_array_i8 * const restrict,
- gfc_array_i8 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_i8 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_8_i8);
void
mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
gfc_array_i8 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_8_i8 (gfc_array_i8 * const restrict,
- gfc_array_i8 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_i8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_i8);
void
sminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
gfc_array_i8 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_8_i8 (retarray, array);
+ minloc0_8_i8 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_8)
extern void minloc0_8_r10 (gfc_array_i8 * const restrict retarray,
- gfc_array_r10 * const restrict array);
+ gfc_array_r10 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_8_r10);
void
minloc0_8_r10 (gfc_array_i8 * const restrict retarray,
- gfc_array_r10 * const restrict array)
+ gfc_array_r10 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_8_r10 (gfc_array_i8 * const restrict,
- gfc_array_r10 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r10 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_8_r10);
void
mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
gfc_array_r10 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_8_r10 (gfc_array_i8 * const restrict,
- gfc_array_r10 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r10 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_r10);
void
sminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
gfc_array_r10 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_8_r10 (retarray, array);
+ minloc0_8_r10 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_8)
extern void minloc0_8_r16 (gfc_array_i8 * const restrict retarray,
- gfc_array_r16 * const restrict array);
+ gfc_array_r16 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_8_r16);
void
minloc0_8_r16 (gfc_array_i8 * const restrict retarray,
- gfc_array_r16 * const restrict array)
+ gfc_array_r16 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_8_r16 (gfc_array_i8 * const restrict,
- gfc_array_r16 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r16 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_8_r16);
void
mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
gfc_array_r16 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_8_r16 (gfc_array_i8 * const restrict,
- gfc_array_r16 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r16 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_r16);
void
sminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
gfc_array_r16 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_8_r16 (retarray, array);
+ minloc0_8_r16 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_8)
extern void minloc0_8_r4 (gfc_array_i8 * const restrict retarray,
- gfc_array_r4 * const restrict array);
+ gfc_array_r4 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_8_r4);
void
minloc0_8_r4 (gfc_array_i8 * const restrict retarray,
- gfc_array_r4 * const restrict array)
+ gfc_array_r4 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_8_r4 (gfc_array_i8 * const restrict,
- gfc_array_r4 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r4 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_8_r4);
void
mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
gfc_array_r4 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_8_r4 (gfc_array_i8 * const restrict,
- gfc_array_r4 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_r4);
void
sminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
gfc_array_r4 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_8_r4 (retarray, array);
+ minloc0_8_r4 (retarray, array, back);
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_8)
extern void minloc0_8_r8 (gfc_array_i8 * const restrict retarray,
- gfc_array_r8 * const restrict array);
+ gfc_array_r8 * const restrict array, GFC_LOGICAL_4);
export_proto(minloc0_8_r8);
void
minloc0_8_r8 (gfc_array_i8 * const restrict retarray,
- gfc_array_r8 * const restrict array)
+ gfc_array_r8 * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_8_r8 (gfc_array_i8 * const restrict,
- gfc_array_r8 * const restrict, gfc_array_l1 * const restrict);
+ gfc_array_r8 * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(mminloc0_8_r8);
void
mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
gfc_array_r8 * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_8_r8 (gfc_array_i8 * const restrict,
- gfc_array_r8 * const restrict, GFC_LOGICAL_4 *);
+ gfc_array_r8 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(sminloc0_8_r8);
void
sminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
gfc_array_r8 * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- minloc0_8_r8 (retarray, array);
+ minloc0_8_r8 (retarray, array, back);
return;
}
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
static inline int
compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
{
}
extern void minloc0_8_s1 (gfc_array_i8 * const restrict retarray,
- gfc_array_s1 * const restrict array, gfc_charlen_type len);
+ gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
export_proto(minloc0_8_s1);
void
minloc0_8_s1 (gfc_array_i8 * const restrict retarray,
- gfc_array_s1 * const restrict array, gfc_charlen_type len)
+ gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_8_s1 (gfc_array_i8 * const restrict,
- gfc_array_s1 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+ gfc_array_s1 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(mminloc0_8_s1);
void
mminloc0_8_s1 (gfc_array_i8 * const restrict retarray,
gfc_array_s1 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_8_s1 (gfc_array_i8 * const restrict,
- gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+ gfc_array_s1 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(sminloc0_8_s1);
void
sminloc0_8_s1 (gfc_array_i8 * const restrict retarray,
gfc_array_s1 * const restrict array,
- GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type rank;
index_type dstride;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc0_8_s1 (retarray, array, back, len);
+#else
minloc0_8_s1 (retarray, array, len);
+#endif
return;
}
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
static inline int
compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
{
}
extern void minloc0_8_s4 (gfc_array_i8 * const restrict retarray,
- gfc_array_s4 * const restrict array, gfc_charlen_type len);
+ gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len);
export_proto(minloc0_8_s4);
void
minloc0_8_s4 (gfc_array_i8 * const restrict retarray,
- gfc_array_s4 * const restrict array, gfc_charlen_type len)
+ gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void mminloc0_8_s4 (gfc_array_i8 * const restrict,
- gfc_array_s4 * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
+ gfc_array_s4 * const restrict, gfc_array_l1 * const restrict , GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(mminloc0_8_s4);
void
mminloc0_8_s4 (gfc_array_i8 * const restrict retarray,
gfc_array_s4 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
extern void sminloc0_8_s4 (gfc_array_i8 * const restrict,
- gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
+ gfc_array_s4 * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4 back,
+ gfc_charlen_type len);
export_proto(sminloc0_8_s4);
void
sminloc0_8_s4 (gfc_array_i8 * const restrict retarray,
gfc_array_s4 * const restrict array,
- GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type rank;
index_type dstride;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc0_8_s4 (retarray, array, back, len);
+#else
minloc0_8_s4 (retarray, array, len);
+#endif
return;
}
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_16_i1 (gfc_array_i16 * const restrict,
- gfc_array_i1 * const restrict, const index_type * const restrict);
+ gfc_array_i1 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_16_i1);
void
minloc1_16_i1 (gfc_array_i16 * const restrict retarray,
gfc_array_i1 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_16_i1 (gfc_array_i16 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_16_i1);
void
mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
gfc_array_i1 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_16_i1 (gfc_array_i16 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_16_i1);
void
sminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
gfc_array_i1 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_16_i1 (retarray, array, pdim, back);
+#else
minloc1_16_i1 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_16_i16 (gfc_array_i16 * const restrict,
- gfc_array_i16 * const restrict, const index_type * const restrict);
+ gfc_array_i16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_16_i16);
void
minloc1_16_i16 (gfc_array_i16 * const restrict retarray,
gfc_array_i16 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_16_i16 (gfc_array_i16 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_16_i16);
void
mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
gfc_array_i16 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_16_i16 (gfc_array_i16 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_16_i16);
void
sminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
gfc_array_i16 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_16_i16 (retarray, array, pdim, back);
+#else
minloc1_16_i16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_16_i2 (gfc_array_i16 * const restrict,
- gfc_array_i2 * const restrict, const index_type * const restrict);
+ gfc_array_i2 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_16_i2);
void
minloc1_16_i2 (gfc_array_i16 * const restrict retarray,
gfc_array_i2 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_16_i2 (gfc_array_i16 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_16_i2);
void
mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
gfc_array_i2 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_16_i2 (gfc_array_i16 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_16_i2);
void
sminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
gfc_array_i2 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_16_i2 (retarray, array, pdim, back);
+#else
minloc1_16_i2 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_16_i4 (gfc_array_i16 * const restrict,
- gfc_array_i4 * const restrict, const index_type * const restrict);
+ gfc_array_i4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_16_i4);
void
minloc1_16_i4 (gfc_array_i16 * const restrict retarray,
gfc_array_i4 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_16_i4 (gfc_array_i16 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_16_i4);
void
mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
gfc_array_i4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_16_i4 (gfc_array_i16 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_16_i4);
void
sminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
gfc_array_i4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_16_i4 (retarray, array, pdim, back);
+#else
minloc1_16_i4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_16_i8 (gfc_array_i16 * const restrict,
- gfc_array_i8 * const restrict, const index_type * const restrict);
+ gfc_array_i8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_16_i8);
void
minloc1_16_i8 (gfc_array_i16 * const restrict retarray,
gfc_array_i8 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_16_i8 (gfc_array_i16 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_16_i8);
void
mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
gfc_array_i8 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_16_i8 (gfc_array_i16 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_16_i8);
void
sminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
gfc_array_i8 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_16_i8 (retarray, array, pdim, back);
+#else
minloc1_16_i8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_16_r10 (gfc_array_i16 * const restrict,
- gfc_array_r10 * const restrict, const index_type * const restrict);
+ gfc_array_r10 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_16_r10);
void
minloc1_16_r10 (gfc_array_i16 * const restrict retarray,
gfc_array_r10 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_16_r10 (gfc_array_i16 * const restrict,
gfc_array_r10 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_16_r10);
void
mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
gfc_array_r10 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_16_r10 (gfc_array_i16 * const restrict,
gfc_array_r10 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_16_r10);
void
sminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
gfc_array_r10 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_16_r10 (retarray, array, pdim, back);
+#else
minloc1_16_r10 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_16_r16 (gfc_array_i16 * const restrict,
- gfc_array_r16 * const restrict, const index_type * const restrict);
+ gfc_array_r16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_16_r16);
void
minloc1_16_r16 (gfc_array_i16 * const restrict retarray,
gfc_array_r16 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_16_r16 (gfc_array_i16 * const restrict,
gfc_array_r16 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_16_r16);
void
mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
gfc_array_r16 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_16_r16 (gfc_array_i16 * const restrict,
gfc_array_r16 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_16_r16);
void
sminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
gfc_array_r16 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_16_r16 (retarray, array, pdim, back);
+#else
minloc1_16_r16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_16_r4 (gfc_array_i16 * const restrict,
- gfc_array_r4 * const restrict, const index_type * const restrict);
+ gfc_array_r4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_16_r4);
void
minloc1_16_r4 (gfc_array_i16 * const restrict retarray,
gfc_array_r4 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_16_r4 (gfc_array_i16 * const restrict,
gfc_array_r4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_16_r4);
void
mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
gfc_array_r4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_16_r4 (gfc_array_i16 * const restrict,
gfc_array_r4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_16_r4);
void
sminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
gfc_array_r4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_16_r4 (retarray, array, pdim, back);
+#else
minloc1_16_r4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_16_r8 (gfc_array_i16 * const restrict,
- gfc_array_r8 * const restrict, const index_type * const restrict);
+ gfc_array_r8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_16_r8);
void
minloc1_16_r8 (gfc_array_i16 * const restrict retarray,
gfc_array_r8 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_16_r8 (gfc_array_i16 * const restrict,
gfc_array_r8 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_16_r8);
void
mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
gfc_array_r8 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_16_r8 (gfc_array_i16 * const restrict,
gfc_array_r8 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_16_r8);
void
sminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
gfc_array_r8 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_16_r8 (retarray, array, pdim, back);
+#else
minloc1_16_r8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
#include <string.h>
+#include <assert.h>
static inline int
compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
}
extern void minloc1_16_s1 (gfc_array_i16 * const restrict,
- gfc_array_s1 * const restrict, const index_type * const restrict,
+ gfc_array_s1 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(minloc1_16_s1);
void
minloc1_16_s1 (gfc_array_i16 * const restrict retarray,
gfc_array_s1 * const restrict array,
- const index_type * const restrict pdim, gfc_charlen_type string_len)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_16_s1 (gfc_array_i16 * const restrict,
gfc_array_s1 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict, gfc_charlen_type);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(mminloc1_16_s1);
void
mminloc1_16_s1 (gfc_array_i16 * const restrict retarray,
gfc_array_s1 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_16_s1 (gfc_array_i16 * const restrict,
gfc_array_s1 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *, gfc_charlen_type);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(sminloc1_16_s1);
void
sminloc1_16_s1 (gfc_array_i16 * const restrict retarray,
gfc_array_s1 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+ GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_16_s1 (retarray, array, pdim, back, string_len);
+#else
minloc1_16_s1 (retarray, array, pdim, string_len);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
+#define HAVE_BACK_ARG 1
+
#include <string.h>
+#include <assert.h>
static inline int
compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
}
extern void minloc1_16_s4 (gfc_array_i16 * const restrict,
- gfc_array_s4 * const restrict, const index_type * const restrict,
+ gfc_array_s4 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(minloc1_16_s4);
void
minloc1_16_s4 (gfc_array_i16 * const restrict retarray,
gfc_array_s4 * const restrict array,
- const index_type * const restrict pdim, gfc_charlen_type string_len)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_16_s4 (gfc_array_i16 * const restrict,
gfc_array_s4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict, gfc_charlen_type);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(mminloc1_16_s4);
void
mminloc1_16_s4 (gfc_array_i16 * const restrict retarray,
gfc_array_s4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_16_s4 (gfc_array_i16 * const restrict,
gfc_array_s4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *, gfc_charlen_type);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(sminloc1_16_s4);
void
sminloc1_16_s4 (gfc_array_i16 * const restrict retarray,
gfc_array_s4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+ GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_16_s4 (retarray, array, pdim, back, string_len);
+#else
minloc1_16_s4 (retarray, array, pdim, string_len);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_4_i1 (gfc_array_i4 * const restrict,
- gfc_array_i1 * const restrict, const index_type * const restrict);
+ gfc_array_i1 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_4_i1);
void
minloc1_4_i1 (gfc_array_i4 * const restrict retarray,
gfc_array_i1 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_4_i1 (gfc_array_i4 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_4_i1);
void
mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
gfc_array_i1 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_4_i1 (gfc_array_i4 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_4_i1);
void
sminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
gfc_array_i1 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_4_i1 (retarray, array, pdim, back);
+#else
minloc1_4_i1 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_4_i16 (gfc_array_i4 * const restrict,
- gfc_array_i16 * const restrict, const index_type * const restrict);
+ gfc_array_i16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_4_i16);
void
minloc1_4_i16 (gfc_array_i4 * const restrict retarray,
gfc_array_i16 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_4_i16 (gfc_array_i4 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_4_i16);
void
mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
gfc_array_i16 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_4_i16 (gfc_array_i4 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_4_i16);
void
sminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
gfc_array_i16 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_4_i16 (retarray, array, pdim, back);
+#else
minloc1_4_i16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_4_i2 (gfc_array_i4 * const restrict,
- gfc_array_i2 * const restrict, const index_type * const restrict);
+ gfc_array_i2 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_4_i2);
void
minloc1_4_i2 (gfc_array_i4 * const restrict retarray,
gfc_array_i2 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_4_i2 (gfc_array_i4 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_4_i2);
void
mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
gfc_array_i2 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_4_i2 (gfc_array_i4 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_4_i2);
void
sminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
gfc_array_i2 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_4_i2 (retarray, array, pdim, back);
+#else
minloc1_4_i2 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_4_i4 (gfc_array_i4 * const restrict,
- gfc_array_i4 * const restrict, const index_type * const restrict);
+ gfc_array_i4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_4_i4);
void
minloc1_4_i4 (gfc_array_i4 * const restrict retarray,
gfc_array_i4 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_4_i4 (gfc_array_i4 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_4_i4);
void
mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
gfc_array_i4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_4_i4 (gfc_array_i4 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_4_i4);
void
sminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
gfc_array_i4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_4_i4 (retarray, array, pdim, back);
+#else
minloc1_4_i4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_4_i8 (gfc_array_i4 * const restrict,
- gfc_array_i8 * const restrict, const index_type * const restrict);
+ gfc_array_i8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_4_i8);
void
minloc1_4_i8 (gfc_array_i4 * const restrict retarray,
gfc_array_i8 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_4_i8 (gfc_array_i4 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_4_i8);
void
mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
gfc_array_i8 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_4_i8 (gfc_array_i4 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_4_i8);
void
sminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
gfc_array_i8 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_4_i8 (retarray, array, pdim, back);
+#else
minloc1_4_i8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_4_r10 (gfc_array_i4 * const restrict,
- gfc_array_r10 * const restrict, const index_type * const restrict);
+ gfc_array_r10 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_4_r10);
void
minloc1_4_r10 (gfc_array_i4 * const restrict retarray,
gfc_array_r10 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_4_r10 (gfc_array_i4 * const restrict,
gfc_array_r10 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_4_r10);
void
mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
gfc_array_r10 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_4_r10 (gfc_array_i4 * const restrict,
gfc_array_r10 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_4_r10);
void
sminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
gfc_array_r10 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_4_r10 (retarray, array, pdim, back);
+#else
minloc1_4_r10 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_4_r16 (gfc_array_i4 * const restrict,
- gfc_array_r16 * const restrict, const index_type * const restrict);
+ gfc_array_r16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_4_r16);
void
minloc1_4_r16 (gfc_array_i4 * const restrict retarray,
gfc_array_r16 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_4_r16 (gfc_array_i4 * const restrict,
gfc_array_r16 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_4_r16);
void
mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
gfc_array_r16 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_4_r16 (gfc_array_i4 * const restrict,
gfc_array_r16 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_4_r16);
void
sminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
gfc_array_r16 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_4_r16 (retarray, array, pdim, back);
+#else
minloc1_4_r16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_4_r4 (gfc_array_i4 * const restrict,
- gfc_array_r4 * const restrict, const index_type * const restrict);
+ gfc_array_r4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_4_r4);
void
minloc1_4_r4 (gfc_array_i4 * const restrict retarray,
gfc_array_r4 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_4_r4 (gfc_array_i4 * const restrict,
gfc_array_r4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_4_r4);
void
mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
gfc_array_r4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_4_r4 (gfc_array_i4 * const restrict,
gfc_array_r4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_4_r4);
void
sminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
gfc_array_r4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_4_r4 (retarray, array, pdim, back);
+#else
minloc1_4_r4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_4_r8 (gfc_array_i4 * const restrict,
- gfc_array_r8 * const restrict, const index_type * const restrict);
+ gfc_array_r8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_4_r8);
void
minloc1_4_r8 (gfc_array_i4 * const restrict retarray,
gfc_array_r8 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_4_r8 (gfc_array_i4 * const restrict,
gfc_array_r8 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_4_r8);
void
mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
gfc_array_r8 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_4_r8 (gfc_array_i4 * const restrict,
gfc_array_r8 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_4_r8);
void
sminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
gfc_array_r8 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_4_r8 (retarray, array, pdim, back);
+#else
minloc1_4_r8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
#include <string.h>
+#include <assert.h>
static inline int
compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
}
extern void minloc1_4_s1 (gfc_array_i4 * const restrict,
- gfc_array_s1 * const restrict, const index_type * const restrict,
+ gfc_array_s1 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(minloc1_4_s1);
void
minloc1_4_s1 (gfc_array_i4 * const restrict retarray,
gfc_array_s1 * const restrict array,
- const index_type * const restrict pdim, gfc_charlen_type string_len)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_4_s1 (gfc_array_i4 * const restrict,
gfc_array_s1 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict, gfc_charlen_type);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(mminloc1_4_s1);
void
mminloc1_4_s1 (gfc_array_i4 * const restrict retarray,
gfc_array_s1 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_4_s1 (gfc_array_i4 * const restrict,
gfc_array_s1 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *, gfc_charlen_type);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(sminloc1_4_s1);
void
sminloc1_4_s1 (gfc_array_i4 * const restrict retarray,
gfc_array_s1 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+ GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_4_s1 (retarray, array, pdim, back, string_len);
+#else
minloc1_4_s1 (retarray, array, pdim, string_len);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
+#define HAVE_BACK_ARG 1
+
#include <string.h>
+#include <assert.h>
static inline int
compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
}
extern void minloc1_4_s4 (gfc_array_i4 * const restrict,
- gfc_array_s4 * const restrict, const index_type * const restrict,
+ gfc_array_s4 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(minloc1_4_s4);
void
minloc1_4_s4 (gfc_array_i4 * const restrict retarray,
gfc_array_s4 * const restrict array,
- const index_type * const restrict pdim, gfc_charlen_type string_len)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_4_s4 (gfc_array_i4 * const restrict,
gfc_array_s4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict, gfc_charlen_type);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(mminloc1_4_s4);
void
mminloc1_4_s4 (gfc_array_i4 * const restrict retarray,
gfc_array_s4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_4_s4 (gfc_array_i4 * const restrict,
gfc_array_s4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *, gfc_charlen_type);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(sminloc1_4_s4);
void
sminloc1_4_s4 (gfc_array_i4 * const restrict retarray,
gfc_array_s4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+ GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_4_s4 (retarray, array, pdim, back, string_len);
+#else
minloc1_4_s4 (retarray, array, pdim, string_len);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_8_i1 (gfc_array_i8 * const restrict,
- gfc_array_i1 * const restrict, const index_type * const restrict);
+ gfc_array_i1 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_8_i1);
void
minloc1_8_i1 (gfc_array_i8 * const restrict retarray,
gfc_array_i1 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_8_i1 (gfc_array_i8 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_8_i1);
void
mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
gfc_array_i1 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_8_i1 (gfc_array_i8 * const restrict,
gfc_array_i1 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_8_i1);
void
sminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
gfc_array_i1 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_8_i1 (retarray, array, pdim, back);
+#else
minloc1_8_i1 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_16) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_8_i16 (gfc_array_i8 * const restrict,
- gfc_array_i16 * const restrict, const index_type * const restrict);
+ gfc_array_i16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_8_i16);
void
minloc1_8_i16 (gfc_array_i8 * const restrict retarray,
gfc_array_i16 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_8_i16 (gfc_array_i8 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_8_i16);
void
mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
gfc_array_i16 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_8_i16 (gfc_array_i8 * const restrict,
gfc_array_i16 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_8_i16);
void
sminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
gfc_array_i16 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_8_i16 (retarray, array, pdim, back);
+#else
minloc1_8_i16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_2) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_8_i2 (gfc_array_i8 * const restrict,
- gfc_array_i2 * const restrict, const index_type * const restrict);
+ gfc_array_i2 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_8_i2);
void
minloc1_8_i2 (gfc_array_i8 * const restrict retarray,
gfc_array_i2 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_8_i2 (gfc_array_i8 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_8_i2);
void
mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
gfc_array_i2 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_8_i2 (gfc_array_i8 * const restrict,
gfc_array_i2 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_8_i2);
void
sminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
gfc_array_i2 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_8_i2 (retarray, array, pdim, back);
+#else
minloc1_8_i2 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_8_i4 (gfc_array_i8 * const restrict,
- gfc_array_i4 * const restrict, const index_type * const restrict);
+ gfc_array_i4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_8_i4);
void
minloc1_8_i4 (gfc_array_i8 * const restrict retarray,
gfc_array_i4 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_8_i4 (gfc_array_i8 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_8_i4);
void
mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
gfc_array_i4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_8_i4 (gfc_array_i8 * const restrict,
gfc_array_i4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_8_i4);
void
sminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
gfc_array_i4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_8_i4 (retarray, array, pdim, back);
+#else
minloc1_8_i4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_8) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_8_i8 (gfc_array_i8 * const restrict,
- gfc_array_i8 * const restrict, const index_type * const restrict);
+ gfc_array_i8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_8_i8);
void
minloc1_8_i8 (gfc_array_i8 * const restrict retarray,
gfc_array_i8 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_8_i8 (gfc_array_i8 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_8_i8);
void
mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
gfc_array_i8 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_8_i8 (gfc_array_i8 * const restrict,
gfc_array_i8 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_8_i8);
void
sminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
gfc_array_i8 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_8_i8 (retarray, array, pdim, back);
+#else
minloc1_8_i8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_8_r10 (gfc_array_i8 * const restrict,
- gfc_array_r10 * const restrict, const index_type * const restrict);
+ gfc_array_r10 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_8_r10);
void
minloc1_8_r10 (gfc_array_i8 * const restrict retarray,
gfc_array_r10 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_8_r10 (gfc_array_i8 * const restrict,
gfc_array_r10 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_8_r10);
void
mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
gfc_array_r10 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_8_r10 (gfc_array_i8 * const restrict,
gfc_array_r10 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_8_r10);
void
sminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
gfc_array_r10 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_8_r10 (retarray, array, pdim, back);
+#else
minloc1_8_r10 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_16) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_8_r16 (gfc_array_i8 * const restrict,
- gfc_array_r16 * const restrict, const index_type * const restrict);
+ gfc_array_r16 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_8_r16);
void
minloc1_8_r16 (gfc_array_i8 * const restrict retarray,
gfc_array_r16 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_8_r16 (gfc_array_i8 * const restrict,
gfc_array_r16 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_8_r16);
void
mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
gfc_array_r16 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_8_r16 (gfc_array_i8 * const restrict,
gfc_array_r16 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_8_r16);
void
sminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
gfc_array_r16 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_8_r16 (retarray, array, pdim, back);
+#else
minloc1_8_r16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_4) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_8_r4 (gfc_array_i8 * const restrict,
- gfc_array_r4 * const restrict, const index_type * const restrict);
+ gfc_array_r4 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_8_r4);
void
minloc1_8_r4 (gfc_array_i8 * const restrict retarray,
gfc_array_r4 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_8_r4 (gfc_array_i8 * const restrict,
gfc_array_r4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_8_r4);
void
mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
gfc_array_r4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_8_r4 (gfc_array_i8 * const restrict,
gfc_array_r4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_8_r4);
void
sminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
gfc_array_r4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_8_r4 (retarray, array, pdim, back);
+#else
minloc1_8_r4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
+#include <assert.h>
#if defined (HAVE_GFC_REAL_8) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
extern void minloc1_8_r8 (gfc_array_i8 * const restrict,
- gfc_array_r8 * const restrict, const index_type * const restrict);
+ gfc_array_r8 * const restrict, const index_type * const restrict, GFC_LOGICAL_4 back);
export_proto(minloc1_8_r8);
void
minloc1_8_r8 (gfc_array_i8 * const restrict retarray,
gfc_array_r8 * const restrict array,
- const index_type * const restrict pdim)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_8_r8 (gfc_array_i8 * const restrict,
gfc_array_r8 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back);
export_proto(mminloc1_8_r8);
void
mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
gfc_array_r8 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_8_r8 (gfc_array_i8 * const restrict,
gfc_array_r8 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back);
export_proto(sminloc1_8_r8);
void
sminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
gfc_array_r8 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_8_r8 (retarray, array, pdim, back);
+#else
minloc1_8_r8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
#include <string.h>
+#include <assert.h>
static inline int
compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
}
extern void minloc1_8_s1 (gfc_array_i8 * const restrict,
- gfc_array_s1 * const restrict, const index_type * const restrict,
+ gfc_array_s1 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(minloc1_8_s1);
void
minloc1_8_s1 (gfc_array_i8 * const restrict retarray,
gfc_array_s1 * const restrict array,
- const index_type * const restrict pdim, gfc_charlen_type string_len)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_8_s1 (gfc_array_i8 * const restrict,
gfc_array_s1 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict, gfc_charlen_type);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(mminloc1_8_s1);
void
mminloc1_8_s1 (gfc_array_i8 * const restrict retarray,
gfc_array_s1 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_8_s1 (gfc_array_i8 * const restrict,
gfc_array_s1 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *, gfc_charlen_type);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(sminloc1_8_s1);
void
sminloc1_8_s1 (gfc_array_i8 * const restrict retarray,
gfc_array_s1 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+ GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_8_s1 (retarray, array, pdim, back, string_len);
+#else
minloc1_8_s1 (retarray, array, pdim, string_len);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
+#define HAVE_BACK_ARG 1
+
#include <string.h>
+#include <assert.h>
static inline int
compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
}
extern void minloc1_8_s4 (gfc_array_i8 * const restrict,
- gfc_array_s4 * const restrict, const index_type * const restrict,
+ gfc_array_s4 * const restrict, const index_type * const restrict , GFC_LOGICAL_4 back,
gfc_charlen_type);
export_proto(minloc1_8_s4);
void
minloc1_8_s4 (gfc_array_i8 * const restrict retarray,
gfc_array_s4 * const restrict array,
- const index_type * const restrict pdim, gfc_charlen_type string_len)
+ const index_type * const restrict pdim, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
extern void mminloc1_8_s4 (gfc_array_i8 * const restrict,
gfc_array_s4 * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict, gfc_charlen_type);
+ gfc_array_l1 * const restrict, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(mminloc1_8_s4);
void
mminloc1_8_s4 (gfc_array_i8 * const restrict retarray,
gfc_array_s4 * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
extern void sminloc1_8_s4 (gfc_array_i8 * const restrict,
gfc_array_s4 * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *, gfc_charlen_type);
+ GFC_LOGICAL_4 *, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(sminloc1_8_s4);
void
sminloc1_8_s4 (gfc_array_i8 * const restrict retarray,
gfc_array_s4 * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+ GFC_LOGICAL_4 * mask , GFC_LOGICAL_4 back, gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minloc1_8_s4 (retarray, array, pdim, back, string_len);
+#else
minloc1_8_s4 (retarray, array, pdim, string_len);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
return memcmp_char4 (a, b, n);
}
-extern GFC_INTEGER_16 minloc2_16_s1 (gfc_array_s1 * const restrict, gfc_charlen_type);
+extern GFC_INTEGER_16 minloc2_16_s1 (gfc_array_s1 * const restrict, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(minloc2_16_s1);
GFC_INTEGER_16
-minloc2_16_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
+minloc2_16_s1 (gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type ret;
index_type sstride;
const GFC_INTEGER_1 *maxval;
index_type i;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_16 mminloc2_16_s1 (gfc_array_s1 * const restrict,
- gfc_array_l1 *const restrict mask, gfc_charlen_type);
+ gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(mminloc2_16_s1);
GFC_INTEGER_16
mminloc2_16_s1 (gfc_array_s1 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type ret;
index_type sstride;
int mask_kind;
index_type mstride;
+ assert (back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_16 sminloc2_16_s1 (gfc_array_s1 * const restrict,
- GFC_LOGICAL_4 *mask, gfc_charlen_type);
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(sminloc2_16_s1);
GFC_INTEGER_16
sminloc2_16_s1 (gfc_array_s1 * const restrict array,
- GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
if (mask)
- return minloc2_16_s1 (array, len);
+ return minloc2_16_s1 (array, len, back);
else
return 0;
}
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
return memcmp_char4 (a, b, n);
}
-extern GFC_INTEGER_16 minloc2_16_s4 (gfc_array_s4 * const restrict, gfc_charlen_type);
+extern GFC_INTEGER_16 minloc2_16_s4 (gfc_array_s4 * const restrict, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(minloc2_16_s4);
GFC_INTEGER_16
-minloc2_16_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
+minloc2_16_s4 (gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type ret;
index_type sstride;
const GFC_INTEGER_4 *maxval;
index_type i;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_16 mminloc2_16_s4 (gfc_array_s4 * const restrict,
- gfc_array_l1 *const restrict mask, gfc_charlen_type);
+ gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(mminloc2_16_s4);
GFC_INTEGER_16
mminloc2_16_s4 (gfc_array_s4 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type ret;
index_type sstride;
int mask_kind;
index_type mstride;
+ assert (back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_16 sminloc2_16_s4 (gfc_array_s4 * const restrict,
- GFC_LOGICAL_4 *mask, gfc_charlen_type);
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(sminloc2_16_s4);
GFC_INTEGER_16
sminloc2_16_s4 (gfc_array_s4 * const restrict array,
- GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
if (mask)
- return minloc2_16_s4 (array, len);
+ return minloc2_16_s4 (array, len, back);
else
return 0;
}
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
return memcmp_char4 (a, b, n);
}
-extern GFC_INTEGER_4 minloc2_4_s1 (gfc_array_s1 * const restrict, gfc_charlen_type);
+extern GFC_INTEGER_4 minloc2_4_s1 (gfc_array_s1 * const restrict, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(minloc2_4_s1);
GFC_INTEGER_4
-minloc2_4_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
+minloc2_4_s1 (gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type ret;
index_type sstride;
const GFC_INTEGER_1 *maxval;
index_type i;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_4 mminloc2_4_s1 (gfc_array_s1 * const restrict,
- gfc_array_l1 *const restrict mask, gfc_charlen_type);
+ gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(mminloc2_4_s1);
GFC_INTEGER_4
mminloc2_4_s1 (gfc_array_s1 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type ret;
index_type sstride;
int mask_kind;
index_type mstride;
+ assert (back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_4 sminloc2_4_s1 (gfc_array_s1 * const restrict,
- GFC_LOGICAL_4 *mask, gfc_charlen_type);
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(sminloc2_4_s1);
GFC_INTEGER_4
sminloc2_4_s1 (gfc_array_s1 * const restrict array,
- GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
if (mask)
- return minloc2_4_s1 (array, len);
+ return minloc2_4_s1 (array, len, back);
else
return 0;
}
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
return memcmp_char4 (a, b, n);
}
-extern GFC_INTEGER_4 minloc2_4_s4 (gfc_array_s4 * const restrict, gfc_charlen_type);
+extern GFC_INTEGER_4 minloc2_4_s4 (gfc_array_s4 * const restrict, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(minloc2_4_s4);
GFC_INTEGER_4
-minloc2_4_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
+minloc2_4_s4 (gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type ret;
index_type sstride;
const GFC_INTEGER_4 *maxval;
index_type i;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_4 mminloc2_4_s4 (gfc_array_s4 * const restrict,
- gfc_array_l1 *const restrict mask, gfc_charlen_type);
+ gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(mminloc2_4_s4);
GFC_INTEGER_4
mminloc2_4_s4 (gfc_array_s4 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type ret;
index_type sstride;
int mask_kind;
index_type mstride;
+ assert (back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_4 sminloc2_4_s4 (gfc_array_s4 * const restrict,
- GFC_LOGICAL_4 *mask, gfc_charlen_type);
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(sminloc2_4_s4);
GFC_INTEGER_4
sminloc2_4_s4 (gfc_array_s4 * const restrict array,
- GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
if (mask)
- return minloc2_4_s4 (array, len);
+ return minloc2_4_s4 (array, len, back);
else
return 0;
}
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
return memcmp_char4 (a, b, n);
}
-extern GFC_INTEGER_8 minloc2_8_s1 (gfc_array_s1 * const restrict, gfc_charlen_type);
+extern GFC_INTEGER_8 minloc2_8_s1 (gfc_array_s1 * const restrict, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(minloc2_8_s1);
GFC_INTEGER_8
-minloc2_8_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
+minloc2_8_s1 (gfc_array_s1 * const restrict array, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type ret;
index_type sstride;
const GFC_INTEGER_1 *maxval;
index_type i;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_8 mminloc2_8_s1 (gfc_array_s1 * const restrict,
- gfc_array_l1 *const restrict mask, gfc_charlen_type);
+ gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(mminloc2_8_s1);
GFC_INTEGER_8
mminloc2_8_s1 (gfc_array_s1 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type ret;
index_type sstride;
int mask_kind;
index_type mstride;
+ assert (back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_8 sminloc2_8_s1 (gfc_array_s1 * const restrict,
- GFC_LOGICAL_4 *mask, gfc_charlen_type);
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(sminloc2_8_s1);
GFC_INTEGER_8
sminloc2_8_s1 (gfc_array_s1 * const restrict array,
- GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
if (mask)
- return minloc2_8_s1 (array, len);
+ return minloc2_8_s1 (array, len, back);
else
return 0;
}
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
+#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
return memcmp_char4 (a, b, n);
}
-extern GFC_INTEGER_8 minloc2_8_s4 (gfc_array_s4 * const restrict, gfc_charlen_type);
+extern GFC_INTEGER_8 minloc2_8_s4 (gfc_array_s4 * const restrict, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(minloc2_8_s4);
GFC_INTEGER_8
-minloc2_8_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
+minloc2_8_s4 (gfc_array_s4 * const restrict array, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type ret;
index_type sstride;
const GFC_INTEGER_4 *maxval;
index_type i;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_8 mminloc2_8_s4 (gfc_array_s4 * const restrict,
- gfc_array_l1 *const restrict mask, gfc_charlen_type);
+ gfc_array_l1 *const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type);
export_proto(mminloc2_8_s4);
GFC_INTEGER_8
mminloc2_8_s4 (gfc_array_s4 * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back,
+ gfc_charlen_type len)
{
index_type ret;
index_type sstride;
int mask_kind;
index_type mstride;
+ assert (back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern GFC_INTEGER_8 sminloc2_8_s4 (gfc_array_s4 * const restrict,
- GFC_LOGICAL_4 *mask, gfc_charlen_type);
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type);
export_proto(sminloc2_8_s4);
GFC_INTEGER_8
sminloc2_8_s4 (gfc_array_s4 * const restrict array,
- GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 *mask, GFC_LOGICAL_4 back, gfc_charlen_type len)
{
if (mask)
- return minloc2_8_s4 (array, len);
+ return minloc2_8_s4 (array, len, back);
else
return 0;
}
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minval_i1 (retarray, array, pdim, back);
+#else
minval_i1 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minval_i16 (retarray, array, pdim, back);
+#else
minval_i16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minval_i2 (retarray, array, pdim, back);
+#else
minval_i2 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minval_i4 (retarray, array, pdim, back);
+#else
minval_i4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minval_i8 (retarray, array, pdim, back);
+#else
minval_i8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minval_r10 (retarray, array, pdim, back);
+#else
minval_r10 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minval_r16 (retarray, array, pdim, back);
+#else
minval_r16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minval_r4 (retarray, array, pdim, back);
+#else
minval_r4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ minval_r8 (retarray, array, pdim, back);
+#else
minval_r8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ product_c10 (retarray, array, pdim, back);
+#else
product_c10 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ product_c16 (retarray, array, pdim, back);
+#else
product_c16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ product_c4 (retarray, array, pdim, back);
+#else
product_c4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ product_c8 (retarray, array, pdim, back);
+#else
product_c8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ product_i1 (retarray, array, pdim, back);
+#else
product_i1 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ product_i16 (retarray, array, pdim, back);
+#else
product_i16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ product_i2 (retarray, array, pdim, back);
+#else
product_i2 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ product_i4 (retarray, array, pdim, back);
+#else
product_i4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ product_i8 (retarray, array, pdim, back);
+#else
product_i8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ product_r10 (retarray, array, pdim, back);
+#else
product_r10 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ product_r16 (retarray, array, pdim, back);
+#else
product_r16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ product_r4 (retarray, array, pdim, back);
+#else
product_r4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ product_r8 (retarray, array, pdim, back);
+#else
product_r8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ sum_c10 (retarray, array, pdim, back);
+#else
sum_c10 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ sum_c16 (retarray, array, pdim, back);
+#else
sum_c16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ sum_c4 (retarray, array, pdim, back);
+#else
sum_c4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ sum_c8 (retarray, array, pdim, back);
+#else
sum_c8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ sum_i1 (retarray, array, pdim, back);
+#else
sum_i1 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ sum_i16 (retarray, array, pdim, back);
+#else
sum_i16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ sum_i2 (retarray, array, pdim, back);
+#else
sum_i2 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ sum_i4 (retarray, array, pdim, back);
+#else
sum_i4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ sum_i8 (retarray, array, pdim, back);
+#else
sum_i8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ sum_r10 (retarray, array, pdim, back);
+#else
sum_r10 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ sum_r16 (retarray, array, pdim, back);
+#else
sum_r16 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ sum_r4 (retarray, array, pdim, back);
+#else
sum_r4 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ sum_r8 (retarray, array, pdim, back);
+#else
sum_r8 (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
}
-extern void name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
- atype * const restrict array, gfc_charlen_type len);
-export_proto(name`'rtype_qual`_'atype_code);
+extern void name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
+ 'atype` * const restrict array'back_arg`, gfc_charlen_type len);
+export_proto('name`'rtype_qual`_'atype_code);
void
-name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
- atype * const restrict array, gfc_charlen_type len)
+name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
+ 'atype` * const restrict array'back_arg`, gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride;
- const atype_name *base;
+ const 'atype_name *base;
rtype_name * restrict dest;
index_type rank;
index_type n;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
+
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
}')dnl
define(START_MASKED_FOREACH_FUNCTION,
`
-extern void `m'name`'rtype_qual`_'atype_code (rtype * const restrict,
- atype * const restrict, gfc_array_l1 * const restrict, gfc_charlen_type len);
-export_proto(`m'name`'rtype_qual`_'atype_code);
+extern void `m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict,
+ 'atype` * const restrict, gfc_array_l1 * const restrict 'back_arg`,
+ gfc_charlen_type len);
+export_proto(m'name`'rtype_qual`_'atype_code`);
void
-`m'name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
- atype * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
+ 'atype` * const restrict array,
+ gfc_array_l1 * const restrict mask'back_arg`,
+ gfc_charlen_type len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type sstride[GFC_MAX_DIMENSIONS];
index_type mstride[GFC_MAX_DIMENSIONS];
index_type dstride;
- rtype_name *dest;
+ 'rtype_name *dest;
const atype_name *base;
GFC_LOGICAL_1 *mbase;
int rank;
index_type n;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
FINISH_MASKED_FOREACH_FUNCTION')dnl
define(SCALAR_FOREACH_FUNCTION,
`
-extern void `s'name`'rtype_qual`_'atype_code (rtype * const restrict,
- atype * const restrict, GFC_LOGICAL_4 *, gfc_charlen_type len);
-export_proto(`s'name`'rtype_qual`_'atype_code);
+extern void `s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict,
+ 'atype` * const restrict, GFC_LOGICAL_4 *'back_arg`,
+ gfc_charlen_type len);
+export_proto(s'name`'rtype_qual`_'atype_code);
void
-`s'name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
- atype * const restrict array,
- GFC_LOGICAL_4 * mask, gfc_charlen_type len)
+`s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
+ 'atype` * const restrict array,
+ GFC_LOGICAL_4 * mask'back_arg`,
+ gfc_charlen_type len)
{
index_type rank;
index_type dstride;
index_type n;
- rtype_name *dest;
+ 'rtype_name *dest;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ name`'rtype_qual`_'atype_code (retarray, array, back, len);
+#else
name`'rtype_qual`_'atype_code (retarray, array, len);
+#endif
return;
}
define(START_FOREACH_FUNCTION,
`
extern void name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
- atype * const restrict array);
+ atype * const restrict array, GFC_LOGICAL_4);
export_proto(name`'rtype_qual`_'atype_code);
void
name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
- atype * const restrict array)
+ atype * const restrict array, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type rank;
index_type n;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
define(START_MASKED_FOREACH_FUNCTION,
`
extern void `m'name`'rtype_qual`_'atype_code (rtype * const restrict,
- atype * const restrict, gfc_array_l1 * const restrict);
+ atype * const restrict, gfc_array_l1 * const restrict,
+ GFC_LOGICAL_4);
export_proto(`m'name`'rtype_qual`_'atype_code);
void
`m'name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
atype * const restrict array,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask, GFC_LOGICAL_4 back)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type n;
int mask_kind;
+ assert(back == 0);
rank = GFC_DESCRIPTOR_RANK (array);
if (rank <= 0)
runtime_error ("Rank of array needs to be > 0");
define(SCALAR_FOREACH_FUNCTION,
`
extern void `s'name`'rtype_qual`_'atype_code (rtype * const restrict,
- atype * const restrict, GFC_LOGICAL_4 *);
+ atype * const restrict, GFC_LOGICAL_4 *, GFC_LOGICAL_4);
export_proto(`s'name`'rtype_qual`_'atype_code);
void
`s'name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
atype * const restrict array,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask, GFC_LOGICAL_4 back)
{
index_type rank;
index_type dstride;
if (*mask)
{
- name`'rtype_qual`_'atype_code (retarray, array);
+ name`'rtype_qual`_'atype_code (retarray, array, back);
return;
}
dnl Care should also be taken to avoid using the names defined in iparm.m4
define(START_ARRAY_FUNCTION,
`#include <string.h>
+#include <assert.h>
static inline int
compare_fcn (const atype_name *a, const atype_name *b, gfc_charlen_type n)
return memcmp_char4 (a, b, n);
}
-extern void name`'rtype_qual`_'atype_code (rtype * const restrict,
- atype * const restrict, const index_type * const restrict,
+extern void name`'rtype_qual`_'atype_code (rtype` * const restrict,
+ 'atype` * const restrict, const index_type * const restrict 'back_arg`,
gfc_charlen_type);
-export_proto(name`'rtype_qual`_'atype_code);
+export_proto('name`'rtype_qual`_'atype_code`);
void
-name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
- atype * const restrict array,
- const index_type * const restrict pdim, gfc_charlen_type string_len)
+'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
+ 'atype` * const restrict array,
+ const index_type * const restrict pdim'back_arg`,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS];
- const atype_name * restrict base;
+ const 'atype_name * restrict base;
rtype_name * restrict dest;
index_type rank;
index_type n;
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
}')dnl
define(START_MASKED_ARRAY_FUNCTION,
`
-extern void `m'name`'rtype_qual`_'atype_code (rtype * const restrict,
- atype * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict, gfc_charlen_type);
-export_proto(`m'name`'rtype_qual`_'atype_code);
+extern void `m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict,
+ 'atype` * const restrict, const index_type * const restrict,
+ gfc_array_l1 * const restrict'back_arg`, gfc_charlen_type);
+export_proto(m'name`'rtype_qual`_'atype_code`);
void
-`m'name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
- atype * const restrict array,
+m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
+ 'atype` * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask, gfc_charlen_type string_len)
+ gfc_array_l1 * const restrict mask'back_arg`,
+ gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS];
index_type mstride[GFC_MAX_DIMENSIONS];
- rtype_name * restrict dest;
+ 'rtype_name * restrict dest;
const atype_name * restrict base;
const GFC_LOGICAL_1 * restrict mbase;
index_type rank;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
}')dnl
define(SCALAR_ARRAY_FUNCTION,
`
-extern void `s'name`'rtype_qual`_'atype_code (rtype * const restrict,
- atype * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *, gfc_charlen_type);
-export_proto(`s'name`'rtype_qual`_'atype_code);
+extern void `s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict,
+ 'atype` * const restrict, const index_type * const restrict,
+ GFC_LOGICAL_4 *'back_arg`, gfc_charlen_type);
+export_proto(s'name`'rtype_qual`_'atype_code`);
void
-`s'name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
- atype * const restrict array,
+s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
+ 'atype` * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask, gfc_charlen_type string_len)
+ GFC_LOGICAL_4 * mask 'back_arg`, gfc_charlen_type string_len)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS];
- rtype_name * restrict dest;
+ 'rtype_name * restrict dest;
index_type rank;
index_type n;
index_type dim;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ name`'rtype_qual`_'atype_code (retarray, array, pdim, back, string_len);
+#else
name`'rtype_qual`_'atype_code (retarray, array, pdim, string_len);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
define(START_ARRAY_FUNCTION,
`
extern void name`'rtype_qual`_'atype_code (rtype * const restrict,
- atype * const restrict, const index_type * const restrict);
-export_proto(name`'rtype_qual`_'atype_code);
+ atype` * const restrict, const 'index_type` * const restrict'back_arg`);
+export_proto('name`'rtype_qual`_'atype_code);
void
-name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
- atype * const restrict array,
- const index_type * const restrict pdim)
+name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
+ 'atype` * const restrict array,
+ const index_type * const restrict pdim'back_arg`)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS];
- const atype_name * restrict base;
+ const 'atype_name * restrict base;
rtype_name * restrict dest;
index_type rank;
index_type n;
index_type dim;
int continue_loop;
+#ifdef HAVE_BACK_ARG
+ assert(back == 0);
+#endif
+
/* Make dim zero based to avoid confusion. */
rank = GFC_DESCRIPTOR_RANK (array) - 1;
dim = (*pdim) - 1;
}')dnl
define(START_MASKED_ARRAY_FUNCTION,
`
-extern void `m'name`'rtype_qual`_'atype_code (rtype * const restrict,
- atype * const restrict, const index_type * const restrict,
- gfc_array_l1 * const restrict);
-export_proto(`m'name`'rtype_qual`_'atype_code);
+extern void `m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict,
+ 'atype` * const restrict, const 'index_type` * const restrict,
+ gfc_array_l1 * const restrict'back_arg`);
+export_proto(m'name`'rtype_qual`_'atype_code`);
void
-`m'name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
- atype * const restrict array,
+m'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
+ 'atype` * const restrict array,
const index_type * const restrict pdim,
- gfc_array_l1 * const restrict mask)
+ gfc_array_l1 * const restrict mask'back_arg`)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type sstride[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS];
index_type mstride[GFC_MAX_DIMENSIONS];
- rtype_name * restrict dest;
+ 'rtype_name * restrict dest;
const atype_name * restrict base;
const GFC_LOGICAL_1 * restrict mbase;
index_type rank;
index_type mdelta;
int mask_kind;
+#ifdef HAVE_BACK_ARG
+ assert (back == 0);
+#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
}')dnl
define(SCALAR_ARRAY_FUNCTION,
`
-extern void `s'name`'rtype_qual`_'atype_code (rtype * const restrict,
- atype * const restrict, const index_type * const restrict,
- GFC_LOGICAL_4 *);
-export_proto(`s'name`'rtype_qual`_'atype_code);
+extern void `s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict,
+ 'atype` * const restrict, const index_type * const restrict,
+ GFC_LOGICAL_4 *'back_arg`);
+export_proto(s'name`'rtype_qual`_'atype_code);
void
-`s'name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
- atype * const restrict array,
+`s'name`'rtype_qual`_'atype_code` ('rtype` * const restrict retarray,
+ 'atype` * const restrict array,
const index_type * const restrict pdim,
- GFC_LOGICAL_4 * mask)
+ GFC_LOGICAL_4 * mask'back_arg`)
{
index_type count[GFC_MAX_DIMENSIONS];
index_type extent[GFC_MAX_DIMENSIONS];
index_type dstride[GFC_MAX_DIMENSIONS];
- rtype_name * restrict dest;
+ 'rtype_name * restrict dest;
index_type rank;
index_type n;
index_type dim;
if (*mask)
{
+#ifdef HAVE_BACK_ARG
+ name`'rtype_qual`_'atype_code (retarray, array, pdim, back);
+#else
name`'rtype_qual`_'atype_code (retarray, array, pdim);
+#endif
return;
}
/* Make dim zero based to avoid confusion. */
define(`u_name',`regexp(upcase(name),`\([A-Z]*\)',`\1')')dnl
define(rtype_ccode,ifelse(rtype_letter,`i',rtype_kind,rtype_code))dnl
define(initval,ifelse(index(name,`maxval'),0,0,index(name,`minval'),0,255))dnl
+define(back_arg,ifelse(index(name,`maxloc'),0,``, GFC_LOGICAL_4 back'',dnl
+index(name,`minloc'),0,``, GFC_LOGICAL_4 back''))dnl
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
-#include "libgfortran.h"'
+#include "libgfortran.h"
+#include <assert.h>'
include(iparm.m4)dnl
include(iforeach.m4)dnl
`#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)'
+#define HAVE_BACK_ARG 1
+
FOREACH_FUNCTION(
` const atype_name *maxval;
maxval = base;'
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
-#include "libgfortran.h"'
+#include "libgfortran.h"
+#include <assert.h>'
include(iparm.m4)dnl
include(ifunction.m4)dnl
`#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)'
+#define HAVE_BACK_ARG 1
+
ARRAY_FUNCTION(0,
` atype_name maxval;
#if defined ('atype_inf`)
`#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)'
+#define HAVE_BACK_ARG 1
+
ARRAY_FUNCTION(0,
` const atype_name *maxval;
maxval = base;
#include "libgfortran.h"
#include <stdlib.h>
-#include <string.h>'
+#include <string.h>
+#include <assert.h>'
include(iparm.m4)dnl
`#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)
return memcmp_char4 (a, b, n);
}
-extern 'rtype_name` 'name`'rtype_qual`_'atype_code` ('atype` * const restrict,
+extern 'rtype_name` 'name`'rtype_qual`_'atype_code` ('atype` * const restrict'back_arg`,
gfc_charlen_type);
export_proto('name`'rtype_qual`_'atype_code`);
'rtype_name`
-'name`'rtype_qual`_'atype_code` ('atype` * const restrict array, gfc_charlen_type len)
+'name`'rtype_qual`_'atype_code` ('atype` * const restrict array'back_arg`, gfc_charlen_type len)
{
index_type ret;
index_type sstride;
const 'atype_name` *maxval;
index_type i;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern 'rtype_name` m'name`'rtype_qual`_'atype_code` ('atype` * const restrict,
- gfc_array_l1 *const restrict mask, gfc_charlen_type);
+ gfc_array_l1 *const restrict mask'back_arg`,
+ gfc_charlen_type);
export_proto(m'name`'rtype_qual`_'atype_code`);
'rtype_name`
m'name`'rtype_qual`_'atype_code` ('atype` * const restrict array,
- gfc_array_l1 * const restrict mask,
+ gfc_array_l1 * const restrict mask'back_arg`,
gfc_charlen_type len)
{
index_type ret;
int mask_kind;
index_type mstride;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern 'rtype_name` s'name`'rtype_qual`_'atype_code` ('atype` * const restrict,
- GFC_LOGICAL_4 *mask, gfc_charlen_type);
+ GFC_LOGICAL_4 *mask'back_arg`, gfc_charlen_type);
export_proto(s'name`'rtype_qual`_'atype_code`);
'rtype_name`
s'name`'rtype_qual`_'atype_code` ('atype` * const restrict array,
- GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 *mask'back_arg`, gfc_charlen_type len)
{
if (mask)
- return 'name`'rtype_qual`_'atype_code` (array, len);
+ return 'name`'rtype_qual`_'atype_code` (array, len, back);
else
return 0;
}
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
-#include "libgfortran.h"'
+#include "libgfortran.h"
+#include <assert.h>'
include(iparm.m4)dnl
include(iforeach.m4)dnl
`#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)'
+#define HAVE_BACK_ARG 1
+
FOREACH_FUNCTION(
` const atype_name *minval;
minval = base;'
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
-#include "libgfortran.h"'
+#include "libgfortran.h"
+#include <assert.h>'
include(iparm.m4)dnl
include(ifunction.m4)dnl
`#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)'
+#define HAVE_BACK_ARG 1
+
ARRAY_FUNCTION(0,
` atype_name minval;
#if defined ('atype_inf`)
`#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)'
+#define HAVE_BACK_ARG 1
+
ARRAY_FUNCTION(0,
` const atype_name *minval;
minval = base;
#include "libgfortran.h"
#include <stdlib.h>
-#include <string.h>'
+#include <string.h>
+#include <assert.h>'
include(iparm.m4)dnl
`#if defined (HAVE_'atype_name`) && defined (HAVE_'rtype_name`)
return memcmp_char4 (a, b, n);
}
-extern 'rtype_name` 'name`'rtype_qual`_'atype_code` ('atype` * const restrict, gfc_charlen_type);
+extern 'rtype_name` 'name`'rtype_qual`_'atype_code` ('atype` * const restrict'back_arg`,
+ gfc_charlen_type);
export_proto('name`'rtype_qual`_'atype_code`);
'rtype_name`
-'name`'rtype_qual`_'atype_code` ('atype` * const restrict array, gfc_charlen_type len)
+'name`'rtype_qual`_'atype_code` ('atype` * const restrict array'back_arg`,
+ gfc_charlen_type len)
{
index_type ret;
index_type sstride;
const 'atype_name` *maxval;
index_type i;
+ assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern 'rtype_name` m'name`'rtype_qual`_'atype_code` ('atype` * const restrict,
- gfc_array_l1 *const restrict mask, gfc_charlen_type);
+ gfc_array_l1 *const restrict mask'back_arg`,
+ gfc_charlen_type);
export_proto(m'name`'rtype_qual`_'atype_code`);
'rtype_name`
m'name`'rtype_qual`_'atype_code` ('atype` * const restrict array,
- gfc_array_l1 * const restrict mask, gfc_charlen_type len)
+ gfc_array_l1 * const restrict mask'back_arg`,
+ gfc_charlen_type len)
{
index_type ret;
index_type sstride;
int mask_kind;
index_type mstride;
+ assert (back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
}
extern 'rtype_name` s'name`'rtype_qual`_'atype_code` ('atype` * const restrict,
- GFC_LOGICAL_4 *mask, gfc_charlen_type);
+ GFC_LOGICAL_4 *mask'back_arg`, gfc_charlen_type);
export_proto(s'name`'rtype_qual`_'atype_code`);
'rtype_name`
s'name`'rtype_qual`_'atype_code` ('atype` * const restrict array,
- GFC_LOGICAL_4 *mask, gfc_charlen_type len)
+ GFC_LOGICAL_4 *mask'back_arg`, gfc_charlen_type len)
{
if (mask)
- return 'name`'rtype_qual`_'atype_code` (array, len);
+ return 'name`'rtype_qual`_'atype_code` (array, len, back);
else
return 0;
}
projects / gcc.git / commitdiff