mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-04-07 20:10:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

re PR fortran/54613 ([F08] Add FINDLOC plus support MAXLOC/MINLOC with KIND=/BACK=)

Browse Source 
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-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-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.

From-SVN: r256705
This commit is contained in:
Thomas Koenig 2018-01-15 18:35:13 +00:00
parent 650d669bb4
commit 64b1806b2d
240 changed files with 3713 additions and 1064 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
gcc/fortran/ChangeLog
View File

@ -1,3 +1,29 @@
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
@ -6,7 +32,7 @@
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

25
gcc/fortran/check.c
View File

@ -3265,12 +3265,13 @@ gfc_check_matmul (gfc_expr *matrix_a, gfc_expr *matrix_b)
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))
@ -3279,6 +3280,26 @@ gfc_check_minloc_maxloc (gfc_actual_arglist *ap)
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)

4
gcc/fortran/gfortran.h
View File

@ -1999,7 +1999,7 @@ typedef union
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 *);
@ -2915,6 +2915,8 @@ extern int gfc_size_kind;
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);

34
gcc/fortran/intrinsic.c
View File

@ -687,29 +687,33 @@ add_sym_3 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt ty
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);
}
@ -1242,7 +1246,7 @@ add_functions (void)
*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;
@ -2457,10 +2461,11 @@ add_functions (void)
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);
@ -2533,11 +2538,12 @@ add_functions (void)
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,
@ -4500,7 +4506,7 @@ check_specific (gfc_intrinsic_sym *specific, gfc_expr *expr, int error_flag)
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)

10
gcc/fortran/intrinsic.h
View File

@ -348,10 +348,12 @@ gfc_expr *gfc_simplify_maskr (gfc_expr *, gfc_expr *);
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 *);
@ -540,7 +542,7 @@ void gfc_resolve_logical (gfc_expr *, gfc_expr *, 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 *);
@ -548,7 +550,7 @@ void gfc_resolve_mask (gfc_expr *, gfc_expr *, 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 *);

22
gcc/fortran/iresolve.c
View File

@ -1697,7 +1697,7 @@ gfc_resolve_max (gfc_expr *f, gfc_actual_arglist *args)
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;
@ -1781,6 +1781,15 @@ gfc_resolve_maxloc (gfc_expr *f, gfc_expr *array, gfc_expr *dim,
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);
}
}
@ -1907,7 +1916,7 @@ gfc_resolve_min (gfc_expr *f, gfc_actual_arglist *args)
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;
@ -1986,6 +1995,15 @@ gfc_resolve_minloc (gfc_expr *f, gfc_expr *array, gfc_expr *dim,
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);
}
}

6
gcc/fortran/simplify.c
View File

@ -5343,13 +5343,15 @@ gfc_simplify_minmaxloc (gfc_expr *array, gfc_expr *dim, gfc_expr *mask,
}
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);
}

46
gcc/fortran/trans-intrinsic.c
View File

@ -4562,13 +4562,22 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
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
@ -4576,22 +4585,19 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
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)
gfc_actual_arglist *a, *b;
a = actual;
while (a->next)
{
actual->next = NULL;
gfc_free_actual_arglist (a2);
}
else
{
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;
@ -8647,6 +8653,14 @@ gfc_conv_intrinsic_function (gfc_se * se, gfc_expr * expr)
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;

7
gcc/testsuite/ChangeLog
View File

@ -1,3 +1,10 @@
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

118
gcc/testsuite/gfortran.dg/minmaxloc_10.f90 Normal file
View File

@ -0,0 +1,118 @@
! { 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

9
gcc/testsuite/gfortran.dg/minmaxloc_11.f90 Normal file
View File

@ -0,0 +1,9 @@
! { 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

11
gcc/testsuite/gfortran.dg/minmaxloc_9.f90 Normal file
View File

@ -0,0 +1,11 @@
! { 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

222
libgfortran/ChangeLog
View File

@ -1,3 +1,225 @@
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

11
libgfortran/generated/iall_i1.c
View File

@ -51,6 +51,10 @@ iall_i1 (gfc_array_i1 * const restrict retarray,
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;
@ -218,6 +222,9 @@ miall_i1 (gfc_array_i1 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -399,7 +406,11 @@ siall_i1 (gfc_array_i1 * const restrict retarray,
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. */

11
libgfortran/generated/iall_i16.c
View File

@ -51,6 +51,10 @@ iall_i16 (gfc_array_i16 * const restrict retarray,
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;
@ -218,6 +222,9 @@ miall_i16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -399,7 +406,11 @@ siall_i16 (gfc_array_i16 * const restrict retarray,
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. */

11
libgfortran/generated/iall_i2.c
View File

@ -51,6 +51,10 @@ iall_i2 (gfc_array_i2 * const restrict retarray,
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;
@ -218,6 +222,9 @@ miall_i2 (gfc_array_i2 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -399,7 +406,11 @@ siall_i2 (gfc_array_i2 * const restrict retarray,
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. */

11
libgfortran/generated/iall_i4.c
View File

@ -51,6 +51,10 @@ iall_i4 (gfc_array_i4 * const restrict retarray,
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;
@ -218,6 +222,9 @@ miall_i4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -399,7 +406,11 @@ siall_i4 (gfc_array_i4 * const restrict retarray,
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. */

11
libgfortran/generated/iall_i8.c
View File

@ -51,6 +51,10 @@ iall_i8 (gfc_array_i8 * const restrict retarray,
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;
@ -218,6 +222,9 @@ miall_i8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -399,7 +406,11 @@ siall_i8 (gfc_array_i8 * const restrict retarray,
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. */

11
libgfortran/generated/iany_i1.c
View File

@ -51,6 +51,10 @@ iany_i1 (gfc_array_i1 * const restrict retarray,
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;
@ -218,6 +222,9 @@ miany_i1 (gfc_array_i1 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -399,7 +406,11 @@ siany_i1 (gfc_array_i1 * const restrict retarray,
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. */

11
libgfortran/generated/iany_i16.c
View File

@ -51,6 +51,10 @@ iany_i16 (gfc_array_i16 * const restrict retarray,
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;
@ -218,6 +222,9 @@ miany_i16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -399,7 +406,11 @@ siany_i16 (gfc_array_i16 * const restrict retarray,
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. */

11
libgfortran/generated/iany_i2.c
View File

@ -51,6 +51,10 @@ iany_i2 (gfc_array_i2 * const restrict retarray,
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;
@ -218,6 +222,9 @@ miany_i2 (gfc_array_i2 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -399,7 +406,11 @@ siany_i2 (gfc_array_i2 * const restrict retarray,
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. */

11
libgfortran/generated/iany_i4.c
View File

@ -51,6 +51,10 @@ iany_i4 (gfc_array_i4 * const restrict retarray,
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;
@ -218,6 +222,9 @@ miany_i4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -399,7 +406,11 @@ siany_i4 (gfc_array_i4 * const restrict retarray,
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. */

11
libgfortran/generated/iany_i8.c
View File

@ -51,6 +51,10 @@ iany_i8 (gfc_array_i8 * const restrict retarray,
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;
@ -218,6 +222,9 @@ miany_i8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -399,7 +406,11 @@ siany_i8 (gfc_array_i8 * const restrict retarray,
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. */

11
libgfortran/generated/iparity_i1.c
View File

@ -51,6 +51,10 @@ iparity_i1 (gfc_array_i1 * const restrict retarray,
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;
@ -218,6 +222,9 @@ miparity_i1 (gfc_array_i1 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -399,7 +406,11 @@ siparity_i1 (gfc_array_i1 * const restrict retarray,
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. */

11
libgfortran/generated/iparity_i16.c
View File

@ -51,6 +51,10 @@ iparity_i16 (gfc_array_i16 * const restrict retarray,
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;
@ -218,6 +222,9 @@ miparity_i16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -399,7 +406,11 @@ siparity_i16 (gfc_array_i16 * const restrict retarray,
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. */

11
libgfortran/generated/iparity_i2.c
View File

@ -51,6 +51,10 @@ iparity_i2 (gfc_array_i2 * const restrict retarray,
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;
@ -218,6 +222,9 @@ miparity_i2 (gfc_array_i2 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -399,7 +406,11 @@ siparity_i2 (gfc_array_i2 * const restrict retarray,
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. */

11
libgfortran/generated/iparity_i4.c
View File

@ -51,6 +51,10 @@ iparity_i4 (gfc_array_i4 * const restrict retarray,
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;
@ -218,6 +222,9 @@ miparity_i4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -399,7 +406,11 @@ siparity_i4 (gfc_array_i4 * const restrict retarray,
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. */

11
libgfortran/generated/iparity_i8.c
View File

@ -51,6 +51,10 @@ iparity_i8 (gfc_array_i8 * const restrict retarray,
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;
@ -218,6 +222,9 @@ miparity_i8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -399,7 +406,11 @@ siparity_i8 (gfc_array_i8 * const restrict retarray,
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. */

18
libgfortran/generated/maxloc0_16_i1.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
if (*mask)
{
maxloc0_16_i1 (retarray, array);
maxloc0_16_i1 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_16_i16.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
if (*mask)
{
maxloc0_16_i16 (retarray, array);
maxloc0_16_i16 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_16_i2.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
if (*mask)
{
maxloc0_16_i2 (retarray, array);
maxloc0_16_i2 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_16_i4.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
if (*mask)
{
maxloc0_16_i4 (retarray, array);
maxloc0_16_i4 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_16_i8.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
if (*mask)
{
maxloc0_16_i8 (retarray, array);
maxloc0_16_i8 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_16_r10.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
if (*mask)
{
maxloc0_16_r10 (retarray, array);
maxloc0_16_r10 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_16_r16.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
if (*mask)
{
maxloc0_16_r16 (retarray, array);
maxloc0_16_r16 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_16_r4.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
if (*mask)
{
maxloc0_16_r4 (retarray, array);
maxloc0_16_r4 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_16_r8.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
if (*mask)
{
maxloc0_16_r8 (retarray, array);
maxloc0_16_r8 (retarray, array, back);
return;
}

29
libgfortran/generated/maxloc0_16_s1.c
View File

@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#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)
{
@ -43,12 +45,12 @@ 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];
@ -59,6 +61,10 @@ maxloc0_16_s1 (gfc_array_i16 * const restrict retarray,
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");
@ -149,13 +155,15 @@ maxloc0_16_s1 (gfc_array_i16 * const restrict retarray,
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];
@ -169,6 +177,9 @@ mmaxloc0_16_s1 (gfc_array_i16 * const restrict retarray,
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");
@ -282,13 +293,15 @@ mmaxloc0_16_s1 (gfc_array_i16 * const restrict retarray,
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;
@ -297,7 +310,11 @@ smaxloc0_16_s1 (gfc_array_i16 * const restrict retarray,
if (*mask)
{
#ifdef HAVE_BACK_ARG
maxloc0_16_s1 (retarray, array, back, len);
#else
maxloc0_16_s1 (retarray, array, len);
#endif
return;
}

29
libgfortran/generated/maxloc0_16_s4.c
View File

@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#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)
{
@ -43,12 +45,12 @@ 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];
@ -59,6 +61,10 @@ maxloc0_16_s4 (gfc_array_i16 * const restrict retarray,
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");
@ -149,13 +155,15 @@ maxloc0_16_s4 (gfc_array_i16 * const restrict retarray,
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];
@ -169,6 +177,9 @@ mmaxloc0_16_s4 (gfc_array_i16 * const restrict retarray,
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");
@ -282,13 +293,15 @@ mmaxloc0_16_s4 (gfc_array_i16 * const restrict retarray,
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;
@ -297,7 +310,11 @@ smaxloc0_16_s4 (gfc_array_i16 * const restrict retarray,
if (*mask)
{
#ifdef HAVE_BACK_ARG
maxloc0_16_s4 (retarray, array, back, len);
#else
maxloc0_16_s4 (retarray, array, len);
#endif
return;
}

18
libgfortran/generated/maxloc0_4_i1.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
if (*mask)
{
maxloc0_4_i1 (retarray, array);
maxloc0_4_i1 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_4_i16.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
if (*mask)
{
maxloc0_4_i16 (retarray, array);
maxloc0_4_i16 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_4_i2.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
if (*mask)
{
maxloc0_4_i2 (retarray, array);
maxloc0_4_i2 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_4_i4.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
if (*mask)
{
maxloc0_4_i4 (retarray, array);
maxloc0_4_i4 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_4_i8.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
if (*mask)
{
maxloc0_4_i8 (retarray, array);
maxloc0_4_i8 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_4_r10.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
if (*mask)
{
maxloc0_4_r10 (retarray, array);
maxloc0_4_r10 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_4_r16.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
if (*mask)
{
maxloc0_4_r16 (retarray, array);
maxloc0_4_r16 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_4_r4.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
if (*mask)
{
maxloc0_4_r4 (retarray, array);
maxloc0_4_r4 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_4_r8.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
if (*mask)
{
maxloc0_4_r8 (retarray, array);
maxloc0_4_r8 (retarray, array, back);
return;
}

29
libgfortran/generated/maxloc0_4_s1.c
View File

@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#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)
{
@ -43,12 +45,12 @@ 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];
@ -59,6 +61,10 @@ maxloc0_4_s1 (gfc_array_i4 * const restrict retarray,
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");
@ -149,13 +155,15 @@ maxloc0_4_s1 (gfc_array_i4 * const restrict retarray,
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];
@ -169,6 +177,9 @@ mmaxloc0_4_s1 (gfc_array_i4 * const restrict retarray,
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");
@ -282,13 +293,15 @@ mmaxloc0_4_s1 (gfc_array_i4 * const restrict retarray,
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;
@ -297,7 +310,11 @@ smaxloc0_4_s1 (gfc_array_i4 * const restrict retarray,
if (*mask)
{
#ifdef HAVE_BACK_ARG
maxloc0_4_s1 (retarray, array, back, len);
#else
maxloc0_4_s1 (retarray, array, len);
#endif
return;
}

29
libgfortran/generated/maxloc0_4_s4.c
View File

@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#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)
{
@ -43,12 +45,12 @@ 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];
@ -59,6 +61,10 @@ maxloc0_4_s4 (gfc_array_i4 * const restrict retarray,
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");
@ -149,13 +155,15 @@ maxloc0_4_s4 (gfc_array_i4 * const restrict retarray,
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];
@ -169,6 +177,9 @@ mmaxloc0_4_s4 (gfc_array_i4 * const restrict retarray,
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");
@ -282,13 +293,15 @@ mmaxloc0_4_s4 (gfc_array_i4 * const restrict retarray,
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;
@ -297,7 +310,11 @@ smaxloc0_4_s4 (gfc_array_i4 * const restrict retarray,
if (*mask)
{
#ifdef HAVE_BACK_ARG
maxloc0_4_s4 (retarray, array, back, len);
#else
maxloc0_4_s4 (retarray, array, len);
#endif
return;
}

18
libgfortran/generated/maxloc0_8_i1.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
if (*mask)
{
maxloc0_8_i1 (retarray, array);
maxloc0_8_i1 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_8_i16.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
if (*mask)
{
maxloc0_8_i16 (retarray, array);
maxloc0_8_i16 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_8_i2.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
if (*mask)
{
maxloc0_8_i2 (retarray, array);
maxloc0_8_i2 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_8_i4.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
if (*mask)
{
maxloc0_8_i4 (retarray, array);
maxloc0_8_i4 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_8_i8.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
if (*mask)
{
maxloc0_8_i8 (retarray, array);
maxloc0_8_i8 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_8_r10.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
if (*mask)
{
maxloc0_8_r10 (retarray, array);
maxloc0_8_r10 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_8_r16.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
if (*mask)
{
maxloc0_8_r16 (retarray, array);
maxloc0_8_r16 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_8_r4.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
if (*mask)
{
maxloc0_8_r4 (retarray, array);
maxloc0_8_r4 (retarray, array, back);
return;
}

18
libgfortran/generated/maxloc0_8_r8.c
View File

@ -24,18 +24,19 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -46,6 +47,7 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
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");
@ -167,13 +169,14 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
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];
@ -187,6 +190,7 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
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");
@ -335,13 +339,13 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
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;
@ -350,7 +354,7 @@ smaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
if (*mask)
{
maxloc0_8_r8 (retarray, array);
maxloc0_8_r8 (retarray, array, back);
return;
}

29
libgfortran/generated/maxloc0_8_s1.c
View File

@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#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)
{
@ -43,12 +45,12 @@ 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];
@ -59,6 +61,10 @@ maxloc0_8_s1 (gfc_array_i8 * const restrict retarray,
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");
@ -149,13 +155,15 @@ maxloc0_8_s1 (gfc_array_i8 * const restrict retarray,
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];
@ -169,6 +177,9 @@ mmaxloc0_8_s1 (gfc_array_i8 * const restrict retarray,
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");
@ -282,13 +293,15 @@ mmaxloc0_8_s1 (gfc_array_i8 * const restrict retarray,
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;
@ -297,7 +310,11 @@ smaxloc0_8_s1 (gfc_array_i8 * const restrict retarray,
if (*mask)
{
#ifdef HAVE_BACK_ARG
maxloc0_8_s1 (retarray, array, back, len);
#else
maxloc0_8_s1 (retarray, array, len);
#endif
return;
}

29
libgfortran/generated/maxloc0_8_s4.c
View File

@ -32,6 +32,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#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)
{
@ -43,12 +45,12 @@ 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];
@ -59,6 +61,10 @@ maxloc0_8_s4 (gfc_array_i8 * const restrict retarray,
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");
@ -149,13 +155,15 @@ maxloc0_8_s4 (gfc_array_i8 * const restrict retarray,
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];
@ -169,6 +177,9 @@ mmaxloc0_8_s4 (gfc_array_i8 * const restrict retarray,
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");
@ -282,13 +293,15 @@ mmaxloc0_8_s4 (gfc_array_i8 * const restrict retarray,
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;
@ -297,7 +310,11 @@ smaxloc0_8_s4 (gfc_array_i8 * const restrict retarray,
if (*mask)
{
#ifdef HAVE_BACK_ARG
maxloc0_8_s4 (retarray, array, back, len);
#else
maxloc0_8_s4 (retarray, array, len);
#endif
return;
}

26
libgfortran/generated/maxloc1_16_i1.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_16_i16.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_16_i2.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_16_i4.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_16_i8.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_16_r10.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_16_r16.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_16_r4.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_16_r8.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
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. */

28
libgfortran/generated/maxloc1_16_s1.c
View File

@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#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)
@ -40,14 +43,15 @@ 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];
@ -62,6 +66,10 @@ maxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
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;
@ -210,14 +218,15 @@ maxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
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];
@ -235,6 +244,9 @@ mmaxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -411,14 +423,14 @@ mmaxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
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];
@ -431,7 +443,11 @@ smaxloc1_16_s1 (gfc_array_i16 * const restrict retarray,
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. */

28
libgfortran/generated/maxloc1_16_s4.c
View File

@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#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)
@ -40,14 +43,15 @@ 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];
@ -62,6 +66,10 @@ maxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
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;
@ -210,14 +218,15 @@ maxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
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];
@ -235,6 +244,9 @@ mmaxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -411,14 +423,14 @@ mmaxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
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];
@ -431,7 +443,11 @@ smaxloc1_16_s4 (gfc_array_i16 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_4_i1.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_4_i16.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_4_i2.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_4_i4.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_4_i8.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_4_r10.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_4_r16.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_4_r4.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_4_r8.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
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. */

28
libgfortran/generated/maxloc1_4_s1.c
View File

@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#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)
@ -40,14 +43,15 @@ 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];
@ -62,6 +66,10 @@ maxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
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;
@ -210,14 +218,15 @@ maxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
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];
@ -235,6 +244,9 @@ mmaxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -411,14 +423,14 @@ mmaxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
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];
@ -431,7 +443,11 @@ smaxloc1_4_s1 (gfc_array_i4 * const restrict retarray,
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. */

28
libgfortran/generated/maxloc1_4_s4.c
View File

@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#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)
@ -40,14 +43,15 @@ 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];
@ -62,6 +66,10 @@ maxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
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;
@ -210,14 +218,15 @@ maxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
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];
@ -235,6 +244,9 @@ mmaxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -411,14 +423,14 @@ mmaxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
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];
@ -431,7 +443,11 @@ smaxloc1_4_s4 (gfc_array_i4 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_8_i1.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_8_i16.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_8_i2.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_8_i4.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_8_i8.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_8_r10.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_8_r16.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_8_r4.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
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. */

26
libgfortran/generated/maxloc1_8_r8.c
View File

@ -24,19 +24,22 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<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];
@ -51,6 +54,10 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
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;
@ -214,14 +221,14 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
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];
@ -239,6 +246,9 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -433,14 +443,14 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
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];
@ -453,7 +463,11 @@ smaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
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. */

28
libgfortran/generated/maxloc1_8_s1.c
View File

@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#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)
@ -40,14 +43,15 @@ 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];
@ -62,6 +66,10 @@ maxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
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;
@ -210,14 +218,15 @@ maxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
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];
@ -235,6 +244,9 @@ mmaxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -411,14 +423,14 @@ mmaxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
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];
@ -431,7 +443,11 @@ smaxloc1_8_s1 (gfc_array_i8 * const restrict retarray,
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. */

28
libgfortran/generated/maxloc1_8_s4.c
View File

@ -28,7 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#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)
@ -40,14 +43,15 @@ 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];
@ -62,6 +66,10 @@ maxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
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;
@ -210,14 +218,15 @@ maxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
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];
@ -235,6 +244,9 @@ mmaxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
index_type mdelta;
int mask_kind;
#ifdef HAVE_BACK_ARG
assert (back == 0);
#endif
dim = (*pdim) - 1;
rank = GFC_DESCRIPTOR_RANK (array) - 1;
@ -411,14 +423,14 @@ mmaxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
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];
@ -431,7 +443,11 @@ smaxloc1_8_s4 (gfc_array_i8 * const restrict retarray,
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. */

18
libgfortran/generated/maxloc2_16_s1.c
View File

@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_16)
@ -38,12 +39,12 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
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;
@ -52,6 +53,7 @@ maxloc2_16_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
const GFC_INTEGER_1 *maxval;
index_type i;
assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@ -74,12 +76,13 @@ maxloc2_16_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
}
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;
@ -92,6 +95,7 @@ mmaxloc2_16_s1 (gfc_array_s1 * const restrict array,
int mask_kind;
index_type mstride;
assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@ -141,15 +145,15 @@ mmaxloc2_16_s1 (gfc_array_s1 * const restrict array,
}
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;
}

18
libgfortran/generated/maxloc2_16_s4.c
View File

@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_16)
@ -38,12 +39,12 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
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;
@ -52,6 +53,7 @@ maxloc2_16_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
const GFC_INTEGER_4 *maxval;
index_type i;
assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@ -74,12 +76,13 @@ maxloc2_16_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
}
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;
@ -92,6 +95,7 @@ mmaxloc2_16_s4 (gfc_array_s4 * const restrict array,
int mask_kind;
index_type mstride;
assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@ -141,15 +145,15 @@ mmaxloc2_16_s4 (gfc_array_s4 * const restrict array,
}
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;
}

18
libgfortran/generated/maxloc2_4_s1.c
View File

@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_4)
@ -38,12 +39,12 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
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;
@ -52,6 +53,7 @@ maxloc2_4_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
const GFC_INTEGER_1 *maxval;
index_type i;
assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@ -74,12 +76,13 @@ maxloc2_4_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
}
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;
@ -92,6 +95,7 @@ mmaxloc2_4_s1 (gfc_array_s1 * const restrict array,
int mask_kind;
index_type mstride;
assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@ -141,15 +145,15 @@ mmaxloc2_4_s1 (gfc_array_s1 * const restrict array,
}
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;
}

18
libgfortran/generated/maxloc2_4_s4.c
View File

@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_4)
@ -38,12 +39,12 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
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;
@ -52,6 +53,7 @@ maxloc2_4_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
const GFC_INTEGER_4 *maxval;
index_type i;
assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@ -74,12 +76,13 @@ maxloc2_4_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
}
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;
@ -92,6 +95,7 @@ mmaxloc2_4_s4 (gfc_array_s4 * const restrict array,
int mask_kind;
index_type mstride;
assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@ -141,15 +145,15 @@ mmaxloc2_4_s4 (gfc_array_s4 * const restrict array,
}
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;
}

18
libgfortran/generated/maxloc2_8_s1.c
View File

@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#if defined (HAVE_GFC_INTEGER_1) && defined (HAVE_GFC_INTEGER_8)
@ -38,12 +39,12 @@ compare_fcn (const GFC_INTEGER_1 *a, const GFC_INTEGER_1 *b, gfc_charlen_type n)
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;
@ -52,6 +53,7 @@ maxloc2_8_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
const GFC_INTEGER_1 *maxval;
index_type i;
assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@ -74,12 +76,13 @@ maxloc2_8_s1 (gfc_array_s1 * const restrict array, gfc_charlen_type len)
}
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;
@ -92,6 +95,7 @@ mmaxloc2_8_s1 (gfc_array_s1 * const restrict array,
int mask_kind;
index_type mstride;
assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@ -141,15 +145,15 @@ mmaxloc2_8_s1 (gfc_array_s1 * const restrict array,
}
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;
}

18
libgfortran/generated/maxloc2_8_s4.c
View File

@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
#include "libgfortran.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#if defined (HAVE_GFC_INTEGER_4) && defined (HAVE_GFC_INTEGER_8)
@ -38,12 +39,12 @@ compare_fcn (const GFC_INTEGER_4 *a, const GFC_INTEGER_4 *b, gfc_charlen_type n)
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;
@ -52,6 +53,7 @@ maxloc2_8_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
const GFC_INTEGER_4 *maxval;
index_type i;
assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@ -74,12 +76,13 @@ maxloc2_8_s4 (gfc_array_s4 * const restrict array, gfc_charlen_type len)
}
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;
@ -92,6 +95,7 @@ mmaxloc2_8_s4 (gfc_array_s4 * const restrict array,
int mask_kind;
index_type mstride;
assert(back == 0);
extent = GFC_DESCRIPTOR_EXTENT(array,0);
if (extent <= 0)
return 0;
@ -141,15 +145,15 @@ mmaxloc2_8_s4 (gfc_array_s4 * const restrict array,
}
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;
}

Some files were not shown because too many files have changed in this diff Show More