blob: 219f04f231709a910eb0a020ba29f2c42b685bda [file] [log] [blame]
/* Build up a list of intrinsic subroutines and functions for the
name-resolution stage.
Copyright (C) 2000-2021 Free Software Foundation, Inc.
Contributed by Andy Vaught & Katherine Holcomb
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "options.h"
#include "gfortran.h"
#include "intrinsic.h"
/* Namespace to hold the resolved symbols for intrinsic subroutines. */
static gfc_namespace *gfc_intrinsic_namespace;
bool gfc_init_expr_flag = false;
/* Pointers to an intrinsic function and its argument names that are being
checked. */
const char *gfc_current_intrinsic;
gfc_intrinsic_arg *gfc_current_intrinsic_arg[MAX_INTRINSIC_ARGS];
locus *gfc_current_intrinsic_where;
static gfc_intrinsic_sym *functions, *subroutines, *conversion, *next_sym;
static gfc_intrinsic_sym *char_conversions;
static gfc_intrinsic_arg *next_arg;
static int nfunc, nsub, nargs, nconv, ncharconv;
static enum
{ SZ_NOTHING = 0, SZ_SUBS, SZ_FUNCS, SZ_CONVS }
sizing;
enum klass
{ CLASS_IMPURE = 0, CLASS_PURE, CLASS_ELEMENTAL,
CLASS_INQUIRY, CLASS_TRANSFORMATIONAL, CLASS_ATOMIC };
#define ACTUAL_NO 0
#define ACTUAL_YES 1
#define REQUIRED 0
#define OPTIONAL 1
/* Return a letter based on the passed type. Used to construct the
name of a type-dependent subroutine. If logical_equals_int is
true, we can treat a logical like an int. */
char
gfc_type_letter (bt type, bool logical_equals_int)
{
char c;
switch (type)
{
case BT_LOGICAL:
if (logical_equals_int)
c = 'i';
else
c = 'l';
break;
case BT_CHARACTER:
c = 's';
break;
case BT_INTEGER:
c = 'i';
break;
case BT_REAL:
c = 'r';
break;
case BT_COMPLEX:
c = 'c';
break;
case BT_HOLLERITH:
c = 'h';
break;
default:
c = 'u';
break;
}
return c;
}
/* Get a symbol for a resolved name. Note, if needed be, the elemental
attribute has be added afterwards. */
gfc_symbol *
gfc_get_intrinsic_sub_symbol (const char *name)
{
gfc_symbol *sym;
gfc_get_symbol (name, gfc_intrinsic_namespace, &sym);
sym->attr.always_explicit = 1;
sym->attr.subroutine = 1;
sym->attr.flavor = FL_PROCEDURE;
sym->attr.proc = PROC_INTRINSIC;
gfc_commit_symbol (sym);
return sym;
}
/* Get a symbol for a resolved function, with its special name. The
actual argument list needs to be set by the caller. */
gfc_symbol *
gfc_get_intrinsic_function_symbol (gfc_expr *expr)
{
gfc_symbol *sym;
gfc_get_symbol (expr->value.function.name, gfc_intrinsic_namespace, &sym);
sym->attr.external = 1;
sym->attr.function = 1;
sym->attr.always_explicit = 1;
sym->attr.proc = PROC_INTRINSIC;
sym->attr.flavor = FL_PROCEDURE;
sym->result = sym;
if (expr->rank > 0)
{
sym->attr.dimension = 1;
sym->as = gfc_get_array_spec ();
sym->as->type = AS_ASSUMED_SHAPE;
sym->as->rank = expr->rank;
}
return sym;
}
/* Find a symbol for a resolved intrinsic procedure, return NULL if
not found. */
gfc_symbol *
gfc_find_intrinsic_symbol (gfc_expr *expr)
{
gfc_symbol *sym;
gfc_find_symbol (expr->value.function.name, gfc_intrinsic_namespace,
0, &sym);
return sym;
}
/* Return a pointer to the name of a conversion function given two
typespecs. */
static const char *
conv_name (gfc_typespec *from, gfc_typespec *to)
{
return gfc_get_string ("__convert_%c%d_%c%d",
gfc_type_letter (from->type), from->kind,
gfc_type_letter (to->type), to->kind);
}
/* Given a pair of typespecs, find the gfc_intrinsic_sym node that
corresponds to the conversion. Returns NULL if the conversion
isn't found. */
static gfc_intrinsic_sym *
find_conv (gfc_typespec *from, gfc_typespec *to)
{
gfc_intrinsic_sym *sym;
const char *target;
int i;
target = conv_name (from, to);
sym = conversion;
for (i = 0; i < nconv; i++, sym++)
if (target == sym->name)
return sym;
return NULL;
}
/* Given a pair of CHARACTER typespecs, find the gfc_intrinsic_sym node
that corresponds to the conversion. Returns NULL if the conversion
isn't found. */
static gfc_intrinsic_sym *
find_char_conv (gfc_typespec *from, gfc_typespec *to)
{
gfc_intrinsic_sym *sym;
const char *target;
int i;
target = conv_name (from, to);
sym = char_conversions;
for (i = 0; i < ncharconv; i++, sym++)
if (target == sym->name)
return sym;
return NULL;
}
/* Check TS29113, C407b for assumed type and C535b for assumed-rank,
and a likewise check for NO_ARG_CHECK. */
static bool
do_ts29113_check (gfc_intrinsic_sym *specific, gfc_actual_arglist *arg)
{
gfc_actual_arglist *a;
for (a = arg; a; a = a->next)
{
if (!a->expr)
continue;
if (a->expr->expr_type == EXPR_VARIABLE
&& (a->expr->symtree->n.sym->attr.ext_attr
& (1 << EXT_ATTR_NO_ARG_CHECK))
&& specific->id != GFC_ISYM_C_LOC
&& specific->id != GFC_ISYM_PRESENT)
{
gfc_error ("Variable with NO_ARG_CHECK attribute at %L is only "
"permitted as argument to the intrinsic functions "
"C_LOC and PRESENT", &a->expr->where);
return false;
}
else if (a->expr->ts.type == BT_ASSUMED
&& specific->id != GFC_ISYM_LBOUND
&& specific->id != GFC_ISYM_PRESENT
&& specific->id != GFC_ISYM_RANK
&& specific->id != GFC_ISYM_SHAPE
&& specific->id != GFC_ISYM_SIZE
&& specific->id != GFC_ISYM_SIZEOF
&& specific->id != GFC_ISYM_UBOUND
&& specific->id != GFC_ISYM_IS_CONTIGUOUS
&& specific->id != GFC_ISYM_C_LOC)
{
gfc_error ("Assumed-type argument at %L is not permitted as actual"
" argument to the intrinsic %s", &a->expr->where,
gfc_current_intrinsic);
return false;
}
else if (a->expr->ts.type == BT_ASSUMED && a != arg)
{
gfc_error ("Assumed-type argument at %L is only permitted as "
"first actual argument to the intrinsic %s",
&a->expr->where, gfc_current_intrinsic);
return false;
}
if (a->expr->rank == -1 && !specific->inquiry)
{
gfc_error ("Assumed-rank argument at %L is only permitted as actual "
"argument to intrinsic inquiry functions",
&a->expr->where);
return false;
}
if (a->expr->rank == -1 && arg != a)
{
gfc_error ("Assumed-rank argument at %L is only permitted as first "
"actual argument to the intrinsic inquiry function %s",
&a->expr->where, gfc_current_intrinsic);
return false;
}
}
return true;
}
/* Interface to the check functions. We break apart an argument list
and call the proper check function rather than forcing each
function to manipulate the argument list. */
static bool
do_check (gfc_intrinsic_sym *specific, gfc_actual_arglist *arg)
{
gfc_expr *a1, *a2, *a3, *a4, *a5;
if (arg == NULL)
return (*specific->check.f0) ();
a1 = arg->expr;
arg = arg->next;
if (arg == NULL)
return (*specific->check.f1) (a1);
a2 = arg->expr;
arg = arg->next;
if (arg == NULL)
return (*specific->check.f2) (a1, a2);
a3 = arg->expr;
arg = arg->next;
if (arg == NULL)
return (*specific->check.f3) (a1, a2, a3);
a4 = arg->expr;
arg = arg->next;
if (arg == NULL)
return (*specific->check.f4) (a1, a2, a3, a4);
a5 = arg->expr;
arg = arg->next;
if (arg == NULL)
return (*specific->check.f5) (a1, a2, a3, a4, a5);
gfc_internal_error ("do_check(): too many args");
}
/*********** Subroutines to build the intrinsic list ****************/
/* Add a single intrinsic symbol to the current list.
Argument list:
char * name of function
int whether function is elemental
int If the function can be used as an actual argument [1]
bt return type of function
int kind of return type of function
int Fortran standard version
check pointer to check function
simplify pointer to simplification function
resolve pointer to resolution function
Optional arguments come in multiples of five:
char * name of argument
bt type of argument
int kind of argument
int arg optional flag (1=optional, 0=required)
sym_intent intent of argument
The sequence is terminated by a NULL name.
[1] Whether a function can or cannot be used as an actual argument is
determined by its presence on the 13.6 list in Fortran 2003. The
following intrinsics, which are GNU extensions, are considered allowed
as actual arguments: ACOSH ATANH DACOSH DASINH DATANH DCONJG DIMAG
ZABS ZCOS ZEXP ZLOG ZSIN ZSQRT. */
static void
add_sym (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type, int kind,
int standard, gfc_check_f check, gfc_simplify_f simplify,
gfc_resolve_f resolve, ...)
{
char buf[GFC_MAX_SYMBOL_LEN + 11]; /* 10 for '_gfortran_', 1 for '\0' */
int optional, first_flag;
sym_intent intent;
va_list argp;
switch (sizing)
{
case SZ_SUBS:
nsub++;
break;
case SZ_FUNCS:
nfunc++;
break;
case SZ_NOTHING:
next_sym->name = gfc_get_string ("%s", name);
strcpy (buf, "_gfortran_");
strcat (buf, name);
next_sym->lib_name = gfc_get_string ("%s", buf);
next_sym->pure = (cl != CLASS_IMPURE);
next_sym->elemental = (cl == CLASS_ELEMENTAL);
next_sym->inquiry = (cl == CLASS_INQUIRY);
next_sym->transformational = (cl == CLASS_TRANSFORMATIONAL);
next_sym->actual_ok = actual_ok;
next_sym->ts.type = type;
next_sym->ts.kind = kind;
next_sym->standard = standard;
next_sym->simplify = simplify;
next_sym->check = check;
next_sym->resolve = resolve;
next_sym->specific = 0;
next_sym->generic = 0;
next_sym->conversion = 0;
next_sym->id = id;
break;
default:
gfc_internal_error ("add_sym(): Bad sizing mode");
}
va_start (argp, resolve);
first_flag = 1;
for (;;)
{
name = va_arg (argp, char *);
if (name == NULL)
break;
type = (bt) va_arg (argp, int);
kind = va_arg (argp, int);
optional = va_arg (argp, int);
intent = (sym_intent) va_arg (argp, int);
if (sizing != SZ_NOTHING)
nargs++;
else
{
next_arg++;
if (first_flag)
next_sym->formal = next_arg;
else
(next_arg - 1)->next = next_arg;
first_flag = 0;
strcpy (next_arg->name, name);
next_arg->ts.type = type;
next_arg->ts.kind = kind;
next_arg->optional = optional;
next_arg->value = 0;
next_arg->intent = intent;
}
}
va_end (argp);
next_sym++;
}
/* Add a symbol to the function list where the function takes
0 arguments. */
static void
add_sym_0 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
int kind, int standard,
bool (*check) (void),
gfc_expr *(*simplify) (void),
void (*resolve) (gfc_expr *))
{
gfc_simplify_f sf;
gfc_check_f cf;
gfc_resolve_f rf;
cf.f0 = check;
sf.f0 = simplify;
rf.f0 = resolve;
add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf,
(void *) 0);
}
/* Add a symbol to the subroutine list where the subroutine takes
0 arguments. */
static void
add_sym_0s (const char *name, gfc_isym_id id, int standard,
void (*resolve) (gfc_code *))
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f1 = NULL;
sf.f1 = NULL;
rf.s1 = resolve;
add_sym (name, id, CLASS_IMPURE, ACTUAL_NO, BT_UNKNOWN, 0, standard, cf, sf,
rf, (void *) 0);
}
/* Add a symbol to the function list where the function takes
1 arguments. */
static void
add_sym_1 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
int kind, int standard,
bool (*check) (gfc_expr *),
gfc_expr *(*simplify) (gfc_expr *),
void (*resolve) (gfc_expr *, gfc_expr *),
const char *a1, bt type1, int kind1, int optional1)
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f1 = check;
sf.f1 = simplify;
rf.f1 = resolve;
add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf,
a1, type1, kind1, optional1, INTENT_IN,
(void *) 0);
}
/* Add a symbol to the function list where the function takes
1 arguments, specifying the intent of the argument. */
static void
add_sym_1_intent (const char *name, gfc_isym_id id, enum klass cl,
int actual_ok, bt type, int kind, int standard,
bool (*check) (gfc_expr *),
gfc_expr *(*simplify) (gfc_expr *),
void (*resolve) (gfc_expr *, gfc_expr *),
const char *a1, bt type1, int kind1, int optional1,
sym_intent intent1)
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f1 = check;
sf.f1 = simplify;
rf.f1 = resolve;
add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf,
a1, type1, kind1, optional1, intent1,
(void *) 0);
}
/* Add a symbol to the subroutine list where the subroutine takes
1 arguments, specifying the intent of the argument. */
static void
add_sym_1s (const char *name, gfc_isym_id id, enum klass cl, bt type, int kind,
int standard, bool (*check) (gfc_expr *),
gfc_expr *(*simplify) (gfc_expr *), void (*resolve) (gfc_code *),
const char *a1, bt type1, int kind1, int optional1,
sym_intent intent1)
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f1 = check;
sf.f1 = simplify;
rf.s1 = resolve;
add_sym (name, id, cl, ACTUAL_NO, type, kind, standard, cf, sf, rf,
a1, type1, kind1, optional1, intent1,
(void *) 0);
}
/* Add a symbol to the subroutine ilst where the subroutine takes one
printf-style character argument and a variable number of arguments
to follow. */
static void
add_sym_1p (const char *name, gfc_isym_id id, enum klass cl, bt type, int kind,
int standard, bool (*check) (gfc_actual_arglist *),
gfc_expr *(*simplify) (gfc_expr*), void (*resolve) (gfc_code *),
const char *a1, bt type1, int kind1, int optional1, sym_intent intent1)
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f1m = check;
sf.f1 = simplify;
rf.s1 = resolve;
add_sym (name, id, cl, ACTUAL_NO, type, kind, standard, cf, sf, rf,
a1, type1, kind1, optional1, intent1,
(void *) 0);
}
/* Add a symbol from the MAX/MIN family of intrinsic functions to the
function. MAX et al take 2 or more arguments. */
static void
add_sym_1m (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 *),
void (*resolve) (gfc_expr *, gfc_actual_arglist *),
const char *a1, bt type1, int kind1, int optional1,
const char *a2, bt type2, int kind2, int optional2)
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f1m = check;
sf.f1 = simplify;
rf.f1m = 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,
(void *) 0);
}
/* Add a symbol to the function list where the function takes
2 arguments. */
static void
add_sym_2 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
int kind, int standard,
bool (*check) (gfc_expr *, gfc_expr *),
gfc_expr *(*simplify) (gfc_expr *, gfc_expr *),
void (*resolve) (gfc_expr *, gfc_expr *, gfc_expr *),
const char *a1, bt type1, int kind1, int optional1,
const char *a2, bt type2, int kind2, int optional2)
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f2 = check;
sf.f2 = simplify;
rf.f2 = 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,
(void *) 0);
}
/* Add a symbol to the function list where the function takes
2 arguments; same as add_sym_2 - but allows to specify the intent. */
static void
add_sym_2_intent (const char *name, gfc_isym_id id, enum klass cl,
int actual_ok, bt type, int kind, int standard,
bool (*check) (gfc_expr *, gfc_expr *),
gfc_expr *(*simplify) (gfc_expr *, gfc_expr *),
void (*resolve) (gfc_expr *, gfc_expr *, gfc_expr *),
const char *a1, bt type1, int kind1, int optional1,
sym_intent intent1, const char *a2, bt type2, int kind2,
int optional2, sym_intent intent2)
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f2 = check;
sf.f2 = simplify;
rf.f2 = resolve;
add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf,
a1, type1, kind1, optional1, intent1,
a2, type2, kind2, optional2, intent2,
(void *) 0);
}
/* Add a symbol to the subroutine list where the subroutine takes
2 arguments, specifying the intent of the arguments. */
static void
add_sym_2s (const char *name, gfc_isym_id id, enum klass cl, bt type,
int kind, int standard,
bool (*check) (gfc_expr *, gfc_expr *),
gfc_expr *(*simplify) (gfc_expr *, gfc_expr *),
void (*resolve) (gfc_code *),
const char *a1, bt type1, int kind1, int optional1,
sym_intent intent1, const char *a2, bt type2, int kind2,
int optional2, sym_intent intent2)
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f2 = check;
sf.f2 = simplify;
rf.s1 = resolve;
add_sym (name, id, cl, ACTUAL_NO, type, kind, standard, cf, sf, rf,
a1, type1, kind1, optional1, intent1,
a2, type2, kind2, optional2, intent2,
(void *) 0);
}
/* Add a symbol to the function list where the function takes
3 arguments. */
static void
add_sym_3 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
int kind, int standard,
bool (*check) (gfc_expr *, gfc_expr *, gfc_expr *),
gfc_expr *(*simplify) (gfc_expr *, gfc_expr *, gfc_expr *),
void (*resolve) (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)
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f3 = check;
sf.f3 = simplify;
rf.f3 = 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,
(void *) 0);
}
/* MINLOC and MAXLOC get special treatment because their
argument might have to be reordered. */
static void
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 *, 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 *a5, bt type5, int kind5, int optional5)
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
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);
}
/* Similar for FINDLOC. */
static void
add_sym_6fl (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 *, gfc_expr *, gfc_expr *),
void (*resolve) (gfc_expr *, 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 *a5, bt type5, int kind5, int optional5,
const char *a6, bt type6, int kind6, int optional6)
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f6fl = check;
sf.f6 = simplify;
rf.f6 = 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,
a6, type6, kind6, optional6, INTENT_IN,
(void *) 0);
}
/* MINVAL, MAXVAL, PRODUCT, and SUM also get special treatment because
their argument also might have to be reordered. */
static void
add_sym_3red (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 *),
void (*resolve) (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)
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f3red = check;
sf.f3 = simplify;
rf.f3 = 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,
(void *) 0);
}
/* Add a symbol to the subroutine list where the subroutine takes
3 arguments, specifying the intent of the arguments. */
static void
add_sym_3s (const char *name, gfc_isym_id id, enum klass cl, bt type,
int kind, int standard,
bool (*check) (gfc_expr *, gfc_expr *, gfc_expr *),
gfc_expr *(*simplify) (gfc_expr *, gfc_expr *, gfc_expr *),
void (*resolve) (gfc_code *),
const char *a1, bt type1, int kind1, int optional1,
sym_intent intent1, const char *a2, bt type2, int kind2,
int optional2, sym_intent intent2, const char *a3, bt type3,
int kind3, int optional3, sym_intent intent3)
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f3 = check;
sf.f3 = simplify;
rf.s1 = resolve;
add_sym (name, id, cl, ACTUAL_NO, type, kind, standard, cf, sf, rf,
a1, type1, kind1, optional1, intent1,
a2, type2, kind2, optional2, intent2,
a3, type3, kind3, optional3, intent3,
(void *) 0);
}
/* Add a symbol to the function list where the function takes
4 arguments. */
static void
add_sym_4 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
int kind, int standard,
bool (*check) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *),
gfc_expr *(*simplify) (gfc_expr *, gfc_expr *, gfc_expr *,
gfc_expr *),
void (*resolve) (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 )
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f4 = check;
sf.f4 = simplify;
rf.f4 = 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,
(void *) 0);
}
/* Add a symbol to the function list where the function takes 4
arguments and resolution may need to change the number or
arrangement of arguments. This is the case for INDEX, which needs
its KIND argument removed. */
static void
add_sym_4ind (const char *name, gfc_isym_id id, enum klass cl, int actual_ok,
bt type, int kind, int standard,
bool (*check) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *),
gfc_expr *(*simplify) (gfc_expr *, gfc_expr *, gfc_expr *,
gfc_expr *),
void (*resolve) (gfc_expr *, gfc_actual_arglist *),
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 )
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f4 = check;
sf.f4 = simplify;
rf.f1m = 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,
(void *) 0);
}
/* Add a symbol to the subroutine list where the subroutine takes
4 arguments. */
static void
add_sym_4s (const char *name, gfc_isym_id id, enum klass cl, bt type, int kind,
int standard,
bool (*check) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *),
gfc_expr *(*simplify) (gfc_expr *, gfc_expr *, gfc_expr *,
gfc_expr *),
void (*resolve) (gfc_code *),
const char *a1, bt type1, int kind1, int optional1,
sym_intent intent1, const char *a2, bt type2, int kind2,
int optional2, sym_intent intent2, const char *a3, bt type3,
int kind3, int optional3, sym_intent intent3, const char *a4,
bt type4, int kind4, int optional4, sym_intent intent4)
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f4 = check;
sf.f4 = simplify;
rf.s1 = resolve;
add_sym (name, id, cl, ACTUAL_NO, type, kind, standard, cf, sf, rf,
a1, type1, kind1, optional1, intent1,
a2, type2, kind2, optional2, intent2,
a3, type3, kind3, optional3, intent3,
a4, type4, kind4, optional4, intent4,
(void *) 0);
}
/* Add a symbol to the subroutine list where the subroutine takes
5 arguments. */
static void
add_sym_5s (const char *name, gfc_isym_id id, enum klass cl, bt type, int kind,
int standard,
bool (*check) (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_code *),
const char *a1, bt type1, int kind1, int optional1,
sym_intent intent1, const char *a2, bt type2, int kind2,
int optional2, sym_intent intent2, const char *a3, bt type3,
int kind3, int optional3, sym_intent intent3, const char *a4,
bt type4, int kind4, int optional4, sym_intent intent4,
const char *a5, bt type5, int kind5, int optional5,
sym_intent intent5)
{
gfc_check_f cf;
gfc_simplify_f sf;
gfc_resolve_f rf;
cf.f5 = check;
sf.f5 = simplify;
rf.s1 = resolve;
add_sym (name, id, cl, ACTUAL_NO, type, kind, standard, cf, sf, rf,
a1, type1, kind1, optional1, intent1,
a2, type2, kind2, optional2, intent2,
a3, type3, kind3, optional3, intent3,
a4, type4, kind4, optional4, intent4,
a5, type5, kind5, optional5, intent5,
(void *) 0);
}
/* Locate an intrinsic symbol given a base pointer, number of elements
in the table and a pointer to a name. Returns the NULL pointer if
a name is not found. */
static gfc_intrinsic_sym *
find_sym (gfc_intrinsic_sym *start, int n, const char *name)
{
/* name may be a user-supplied string, so we must first make sure
that we're comparing against a pointer into the global string
table. */
const char *p = gfc_get_string ("%s", name);
while (n > 0)
{
if (p == start->name)
return start;
start++;
n--;
}
return NULL;
}
gfc_isym_id
gfc_isym_id_by_intmod (intmod_id from_intmod, int intmod_sym_id)
{
if (from_intmod == INTMOD_NONE)
return (gfc_isym_id) intmod_sym_id;
else if (from_intmod == INTMOD_ISO_C_BINDING)
return (gfc_isym_id) c_interop_kinds_table[intmod_sym_id].value;
else if (from_intmod == INTMOD_ISO_FORTRAN_ENV)
switch (intmod_sym_id)
{
#define NAMED_SUBROUTINE(a,b,c,d) \
case a: \
return (gfc_isym_id) c;
#define NAMED_FUNCTION(a,b,c,d) \
case a: \
return (gfc_isym_id) c;
#include "iso-fortran-env.def"
default:
gcc_unreachable ();
}
else
gcc_unreachable ();
return (gfc_isym_id) 0;
}
gfc_isym_id
gfc_isym_id_by_intmod_sym (gfc_symbol *sym)
{
return gfc_isym_id_by_intmod (sym->from_intmod, sym->intmod_sym_id);
}
gfc_intrinsic_sym *
gfc_intrinsic_subroutine_by_id (gfc_isym_id id)
{
gfc_intrinsic_sym *start = subroutines;
int n = nsub;
while (true)
{
gcc_assert (n > 0);
if (id == start->id)
return start;
start++;
n--;
}
}
gfc_intrinsic_sym *
gfc_intrinsic_function_by_id (gfc_isym_id id)
{
gfc_intrinsic_sym *start = functions;
int n = nfunc;
while (true)
{
gcc_assert (n > 0);
if (id == start->id)
return start;
start++;
n--;
}
}
/* Given a name, find a function in the intrinsic function table.
Returns NULL if not found. */
gfc_intrinsic_sym *
gfc_find_function (const char *name)
{
gfc_intrinsic_sym *sym;
sym = find_sym (functions, nfunc, name);
if (!sym || sym->from_module)
sym = find_sym (conversion, nconv, name);
return (!sym || sym->from_module) ? NULL : sym;
}
/* Given a name, find a function in the intrinsic subroutine table.
Returns NULL if not found. */
gfc_intrinsic_sym *
gfc_find_subroutine (const char *name)
{
gfc_intrinsic_sym *sym;
sym = find_sym (subroutines, nsub, name);
return (!sym || sym->from_module) ? NULL : sym;
}
/* Given a string, figure out if it is the name of a generic intrinsic
function or not. */
int
gfc_generic_intrinsic (const char *name)
{
gfc_intrinsic_sym *sym;
sym = gfc_find_function (name);
return (!sym || sym->from_module) ? 0 : sym->generic;
}
/* Given a string, figure out if it is the name of a specific
intrinsic function or not. */
int
gfc_specific_intrinsic (const char *name)
{
gfc_intrinsic_sym *sym;
sym = gfc_find_function (name);
return (!sym || sym->from_module) ? 0 : sym->specific;
}
/* Given a string, figure out if it is the name of an intrinsic function
or subroutine allowed as an actual argument or not. */
int
gfc_intrinsic_actual_ok (const char *name, const bool subroutine_flag)
{
gfc_intrinsic_sym *sym;
/* Intrinsic subroutines are not allowed as actual arguments. */
if (subroutine_flag)
return 0;
else
{
sym = gfc_find_function (name);
return (sym == NULL) ? 0 : sym->actual_ok;
}
}
/* Given a symbol, find out if it is (and is to be treated as) an intrinsic.
If its name refers to an intrinsic, but this intrinsic is not included in
the selected standard, this returns FALSE and sets the symbol's external
attribute. */
bool
gfc_is_intrinsic (gfc_symbol* sym, int subroutine_flag, locus loc)
{
gfc_intrinsic_sym* isym;
const char* symstd;
/* If INTRINSIC attribute is already known, return. */
if (sym->attr.intrinsic)
return true;
/* Check for attributes which prevent the symbol from being INTRINSIC. */
if (sym->attr.external || sym->attr.contained
|| sym->attr.if_source == IFSRC_IFBODY)
return false;
if (subroutine_flag)
isym = gfc_find_subroutine (sym->name);
else
isym = gfc_find_function (sym->name);
/* No such intrinsic available at all? */
if (!isym)
return false;
/* See if this intrinsic is allowed in the current standard. */
if (!gfc_check_intrinsic_standard (isym, &symstd, false, loc)
&& !sym->attr.artificial)
{
if (sym->attr.proc == PROC_UNKNOWN && warn_intrinsics_std)
gfc_warning_now (OPT_Wintrinsics_std, "The intrinsic %qs at %L is not "
"included in the selected standard but %s and %qs will"
" be treated as if declared EXTERNAL. Use an"
" appropriate %<-std=%>* option or define"
" %<-fall-intrinsics%> to allow this intrinsic.",
sym->name, &loc, symstd, sym->name);
return false;
}
return true;
}
/* Collect a set of intrinsic functions into a generic collection.
The first argument is the name of the generic function, which is
also the name of a specific function. The rest of the specifics
currently in the table are placed into the list of specific
functions associated with that generic.
PR fortran/32778
FIXME: Remove the argument STANDARD if no regressions are
encountered. Change all callers (approx. 360).
*/
static void
make_generic (const char *name, gfc_isym_id id, int standard ATTRIBUTE_UNUSED)
{
gfc_intrinsic_sym *g;
if (sizing != SZ_NOTHING)
return;
g = gfc_find_function (name);
if (g == NULL)
gfc_internal_error ("make_generic(): Cannot find generic symbol %qs",
name);
gcc_assert (g->id == id);
g->generic = 1;
g->specific = 1;
if ((g + 1)->name != NULL)
g->specific_head = g + 1;
g++;
while (g->name != NULL)
{
g->next = g + 1;
g->specific = 1;
g++;
}
g--;
g->next = NULL;
}
/* Create a duplicate intrinsic function entry for the current
function, the only differences being the alternate name and
a different standard if necessary. Note that we use argument
lists more than once, but all argument lists are freed as a
single block. */
static void
make_alias (const char *name, int standard)
{
switch (sizing)
{
case SZ_FUNCS:
nfunc++;
break;
case SZ_SUBS:
nsub++;
break;
case SZ_NOTHING:
next_sym[0] = next_sym[-1];
next_sym->name = gfc_get_string ("%s", name);
next_sym->standard = standard;
next_sym++;
break;
default:
break;
}
}
/* Make the current subroutine noreturn. */
static void
make_noreturn (void)
{
if (sizing == SZ_NOTHING)
next_sym[-1].noreturn = 1;
}
/* Mark current intrinsic as module intrinsic. */
static void
make_from_module (void)
{
if (sizing == SZ_NOTHING)
next_sym[-1].from_module = 1;
}
/* Mark the current subroutine as having a variable number of
arguments. */
static void
make_vararg (void)
{
if (sizing == SZ_NOTHING)
next_sym[-1].vararg = 1;
}
/* Set the attr.value of the current procedure. */
static void
set_attr_value (int n, ...)
{
gfc_intrinsic_arg *arg;
va_list argp;
int i;
if (sizing != SZ_NOTHING)
return;
va_start (argp, n);
arg = next_sym[-1].formal;
for (i = 0; i < n; i++)
{
gcc_assert (arg != NULL);
arg->value = va_arg (argp, int);
arg = arg->next;
}
va_end (argp);
}
/* Add intrinsic functions. */
static void
add_functions (void)
{
/* Argument names. These are used as argument keywords and so need to
match the documentation. Please keep this list in sorted order. */
const char
*a = "a", *a1 = "a1", *a2 = "a2", *ar = "array", *b = "b",
*bck = "back", *bd = "boundary", *c = "c", *c_ptr_1 = "c_ptr_1",
*c_ptr_2 = "c_ptr_2", *ca = "coarray", *com = "command",
*dist = "distance", *dm = "dim", *f = "field", *failed="failed",
*fs = "fsource", *han = "handler", *i = "i",
*image = "image", *j = "j", *kind = "kind",
*l = "l", *ln = "len", *level = "level", *m = "matrix", *ma = "matrix_a",
*mb = "matrix_b", *md = "mode", *mo = "mold", *msk = "mask",
*n = "n", *ncopies= "ncopies", *nm = "name", *num = "number",
*ord = "order", *p = "p", *p1 = "path1", *p2 = "path2",
*pad = "pad", *pid = "pid", *pos = "pos", *pt = "pointer",
*r = "r", *s = "s", *set = "set", *sh = "shift", *shp = "shape",
*sig = "sig", *src = "source", *ssg = "substring",
*sta = "string_a", *stb = "string_b", *stg = "string",
*sub = "sub", *sz = "size", *tg = "target", *team = "team", *tm = "time",
*ts = "tsource", *ut = "unit", *v = "vector", *va = "vector_a",
*vb = "vector_b", *vl = "values", *val = "value", *x = "x", *y = "y",
*z = "z";
int di, dr, dd, dl, dc, dz, ii;
di = gfc_default_integer_kind;
dr = gfc_default_real_kind;
dd = gfc_default_double_kind;
dl = gfc_default_logical_kind;
dc = gfc_default_character_kind;
dz = gfc_default_complex_kind;
ii = gfc_index_integer_kind;
add_sym_1 ("abs", GFC_ISYM_ABS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
gfc_check_abs, gfc_simplify_abs, gfc_resolve_abs,
a, BT_REAL, dr, REQUIRED);
if (flag_dec_intrinsic_ints)
{
make_alias ("babs", GFC_STD_GNU);
make_alias ("iiabs", GFC_STD_GNU);
make_alias ("jiabs", GFC_STD_GNU);
make_alias ("kiabs", GFC_STD_GNU);
}
add_sym_1 ("iabs", GFC_ISYM_ABS, CLASS_ELEMENTAL, ACTUAL_YES, BT_INTEGER, di, GFC_STD_F77,
NULL, gfc_simplify_abs, gfc_resolve_abs,
a, BT_INTEGER, di, REQUIRED);
add_sym_1 ("dabs", GFC_ISYM_ABS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
gfc_check_fn_d, gfc_simplify_abs, gfc_resolve_abs,
a, BT_REAL, dd, REQUIRED);
add_sym_1 ("cabs", GFC_ISYM_ABS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
NULL, gfc_simplify_abs, gfc_resolve_abs,
a, BT_COMPLEX, dz, REQUIRED);
add_sym_1 ("zabs", GFC_ISYM_ABS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_GNU,
NULL, gfc_simplify_abs, gfc_resolve_abs,
a, BT_COMPLEX, dd, REQUIRED);
make_alias ("cdabs", GFC_STD_GNU);
make_generic ("abs", GFC_ISYM_ABS, GFC_STD_F77);
/* The checking function for ACCESS is called gfc_check_access_func
because the name gfc_check_access is already used in module.c. */
add_sym_2 ("access", GFC_ISYM_ACCESS, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
di, GFC_STD_GNU, gfc_check_access_func, NULL, gfc_resolve_access,
nm, BT_CHARACTER, dc, REQUIRED, md, BT_CHARACTER, dc, REQUIRED);
make_generic ("access", GFC_ISYM_ACCESS, GFC_STD_GNU);
add_sym_2 ("achar", GFC_ISYM_ACHAR, CLASS_ELEMENTAL, ACTUAL_NO,
BT_CHARACTER, dc, GFC_STD_F95,
gfc_check_achar, gfc_simplify_achar, gfc_resolve_achar,
i, BT_INTEGER, di, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
make_generic ("achar", GFC_ISYM_ACHAR, GFC_STD_F95);
add_sym_1 ("acos", GFC_ISYM_ACOS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
gfc_check_fn_rc2008, gfc_simplify_acos, gfc_resolve_acos,
x, BT_REAL, dr, REQUIRED);
add_sym_1 ("dacos", GFC_ISYM_ACOS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
gfc_check_fn_d, gfc_simplify_acos, gfc_resolve_acos,
x, BT_REAL, dd, REQUIRED);
make_generic ("acos", GFC_ISYM_ACOS, GFC_STD_F77);
add_sym_1 ("acosh", GFC_ISYM_ACOSH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr,
GFC_STD_F2008, gfc_check_fn_rc2008, gfc_simplify_acosh,
gfc_resolve_acosh, x, BT_REAL, dr, REQUIRED);
add_sym_1 ("dacosh", GFC_ISYM_ACOSH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_GNU,
gfc_check_fn_d, gfc_simplify_acosh, gfc_resolve_acosh,
x, BT_REAL, dd, REQUIRED);
make_generic ("acosh", GFC_ISYM_ACOSH, GFC_STD_F2008);
add_sym_1 ("adjustl", GFC_ISYM_ADJUSTL, CLASS_ELEMENTAL, ACTUAL_NO,
BT_CHARACTER, dc, GFC_STD_F95, NULL, gfc_simplify_adjustl,
gfc_resolve_adjustl, stg, BT_CHARACTER, 0, REQUIRED);
make_generic ("adjustl", GFC_ISYM_ADJUSTL, GFC_STD_F95);
add_sym_1 ("adjustr", GFC_ISYM_ADJUSTR, CLASS_ELEMENTAL, ACTUAL_NO,
BT_CHARACTER, dc, GFC_STD_F95, NULL, gfc_simplify_adjustr,
gfc_resolve_adjustr, stg, BT_CHARACTER, 0, REQUIRED);
make_generic ("adjustr", GFC_ISYM_ADJUSTR, GFC_STD_F95);
add_sym_1 ("aimag", GFC_ISYM_AIMAG, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
gfc_check_fn_c, gfc_simplify_aimag, gfc_resolve_aimag,
z, BT_COMPLEX, dz, REQUIRED);
make_alias ("imag", GFC_STD_GNU);
make_alias ("imagpart", GFC_STD_GNU);
add_sym_1 ("dimag", GFC_ISYM_AIMAG, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_GNU,
NULL, gfc_simplify_aimag, gfc_resolve_aimag,
z, BT_COMPLEX, dd, REQUIRED);
make_generic ("aimag", GFC_ISYM_AIMAG, GFC_STD_F77);
add_sym_2 ("aint", GFC_ISYM_AINT, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
gfc_check_a_xkind, gfc_simplify_aint, gfc_resolve_aint,
a, BT_REAL, dr, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
add_sym_1 ("dint", GFC_ISYM_AINT, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
NULL, gfc_simplify_dint, gfc_resolve_dint,
a, BT_REAL, dd, REQUIRED);
make_generic ("aint", GFC_ISYM_AINT, GFC_STD_F77);
add_sym_2 ("all", GFC_ISYM_ALL, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F95,
gfc_check_all_any, gfc_simplify_all, gfc_resolve_all,
msk, BT_LOGICAL, dl, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL);
make_generic ("all", GFC_ISYM_ALL, GFC_STD_F95);
add_sym_1 ("allocated", GFC_ISYM_ALLOCATED, CLASS_INQUIRY, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F95,
gfc_check_allocated, NULL, NULL,
ar, BT_UNKNOWN, 0, REQUIRED);
make_generic ("allocated", GFC_ISYM_ALLOCATED, GFC_STD_F95);
add_sym_2 ("anint", GFC_ISYM_ANINT, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
gfc_check_a_xkind, gfc_simplify_anint, gfc_resolve_anint,
a, BT_REAL, dr, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
add_sym_1 ("dnint", GFC_ISYM_ANINT, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
NULL, gfc_simplify_dnint, gfc_resolve_dnint,
a, BT_REAL, dd, REQUIRED);
make_generic ("anint", GFC_ISYM_ANINT, GFC_STD_F77);
add_sym_2 ("any", GFC_ISYM_ANY, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F95,
gfc_check_all_any, gfc_simplify_any, gfc_resolve_any,
msk, BT_LOGICAL, dl, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL);
make_generic ("any", GFC_ISYM_ANY, GFC_STD_F95);
add_sym_1 ("asin", GFC_ISYM_ASIN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
gfc_check_fn_rc2008, gfc_simplify_asin, gfc_resolve_asin,
x, BT_REAL, dr, REQUIRED);
add_sym_1 ("dasin", GFC_ISYM_ASIN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
gfc_check_fn_d, gfc_simplify_asin, gfc_resolve_asin,
x, BT_REAL, dd, REQUIRED);
make_generic ("asin", GFC_ISYM_ASIN, GFC_STD_F77);
add_sym_1 ("asinh", GFC_ISYM_ASINH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr,
GFC_STD_F2008, gfc_check_fn_rc2008, gfc_simplify_asinh,
gfc_resolve_asinh, x, BT_REAL, dr, REQUIRED);
add_sym_1 ("dasinh", GFC_ISYM_ASINH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_GNU,
gfc_check_fn_d, gfc_simplify_asinh, gfc_resolve_asinh,
x, BT_REAL, dd, REQUIRED);
make_generic ("asinh", GFC_ISYM_ASINH, GFC_STD_F2008);
add_sym_2 ("associated", GFC_ISYM_ASSOCIATED, CLASS_INQUIRY, ACTUAL_NO, BT_LOGICAL, dl,
GFC_STD_F95, gfc_check_associated, NULL, NULL,
pt, BT_UNKNOWN, 0, REQUIRED, tg, BT_UNKNOWN, 0, OPTIONAL);
make_generic ("associated", GFC_ISYM_ASSOCIATED, GFC_STD_F95);
add_sym_1 ("atan", GFC_ISYM_ATAN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
gfc_check_fn_rc2008, gfc_simplify_atan, gfc_resolve_atan,
x, BT_REAL, dr, REQUIRED);
add_sym_1 ("datan", GFC_ISYM_ATAN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
gfc_check_fn_d, gfc_simplify_atan, gfc_resolve_atan,
x, BT_REAL, dd, REQUIRED);
/* Two-argument version of atan, equivalent to atan2. */
add_sym_2 ("atan", GFC_ISYM_ATAN2, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F2008,
gfc_check_atan_2, gfc_simplify_atan2, gfc_resolve_atan2,
y, BT_REAL, dr, REQUIRED, x, BT_REAL, dr, REQUIRED);
make_generic ("atan", GFC_ISYM_ATAN, GFC_STD_F77);
add_sym_1 ("atanh", GFC_ISYM_ATANH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr,
GFC_STD_F2008, gfc_check_fn_rc2008, gfc_simplify_atanh,
gfc_resolve_atanh, x, BT_REAL, dr, REQUIRED);
add_sym_1 ("datanh", GFC_ISYM_ATANH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_GNU,
gfc_check_fn_d, gfc_simplify_atanh, gfc_resolve_atanh,
x, BT_REAL, dd, REQUIRED);
make_generic ("atanh", GFC_ISYM_ATANH, GFC_STD_F2008);
add_sym_2 ("atan2", GFC_ISYM_ATAN2, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
gfc_check_atan2, gfc_simplify_atan2, gfc_resolve_atan2,
y, BT_REAL, dr, REQUIRED, x, BT_REAL, dr, REQUIRED);
add_sym_2 ("datan2", GFC_ISYM_ATAN2, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
gfc_check_datan2, gfc_simplify_atan2, gfc_resolve_atan2,
y, BT_REAL, dd, REQUIRED, x, BT_REAL, dd, REQUIRED);
make_generic ("atan2", GFC_ISYM_ATAN2, GFC_STD_F77);
/* Bessel and Neumann functions for G77 compatibility. */
add_sym_1 ("besj0", GFC_ISYM_J0, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
gfc_check_fn_r, gfc_simplify_bessel_j0, gfc_resolve_g77_math1,
x, BT_REAL, dr, REQUIRED);
make_alias ("bessel_j0", GFC_STD_F2008);
add_sym_1 ("dbesj0", GFC_ISYM_J0, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_GNU,
gfc_check_fn_d, gfc_simplify_bessel_j0, gfc_resolve_g77_math1,
x, BT_REAL, dd, REQUIRED);
make_generic ("bessel_j0", GFC_ISYM_J0, GFC_STD_F2008);
add_sym_1 ("besj1", GFC_ISYM_J1, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
gfc_check_fn_r, gfc_simplify_bessel_j1, gfc_resolve_g77_math1,
x, BT_REAL, dr, REQUIRED);
make_alias ("bessel_j1", GFC_STD_F2008);
add_sym_1 ("dbesj1", GFC_ISYM_J1, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_GNU,
gfc_check_fn_d, gfc_simplify_bessel_j1, gfc_resolve_g77_math1,
x, BT_REAL, dd, REQUIRED);
make_generic ("bessel_j1", GFC_ISYM_J1, GFC_STD_F2008);
add_sym_2 ("besjn", GFC_ISYM_JN, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
gfc_check_besn, gfc_simplify_bessel_jn, gfc_resolve_besn,
n, BT_INTEGER, di, REQUIRED, x, BT_REAL, dr, REQUIRED);
make_alias ("bessel_jn", GFC_STD_F2008);
add_sym_2 ("dbesjn", GFC_ISYM_JN, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_GNU,
gfc_check_besn, gfc_simplify_bessel_jn, gfc_resolve_besn,
n, BT_INTEGER, di, REQUIRED, x, BT_REAL, dd, REQUIRED);
add_sym_3 ("bessel_jn", GFC_ISYM_JN2, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F2008,
gfc_check_bessel_n2, gfc_simplify_bessel_jn2, gfc_resolve_bessel_n2,
"n1", BT_INTEGER, di, REQUIRED,"n2", BT_INTEGER, di, REQUIRED,
x, BT_REAL, dr, REQUIRED);
set_attr_value (3, true, true, true);
make_generic ("bessel_jn", GFC_ISYM_JN, GFC_STD_F2008);
add_sym_1 ("besy0", GFC_ISYM_Y0, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
gfc_check_fn_r, gfc_simplify_bessel_y0, gfc_resolve_g77_math1,
x, BT_REAL, dr, REQUIRED);
make_alias ("bessel_y0", GFC_STD_F2008);
add_sym_1 ("dbesy0", GFC_ISYM_Y0, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_GNU,
gfc_check_fn_d, gfc_simplify_bessel_y0, gfc_resolve_g77_math1,
x, BT_REAL, dd, REQUIRED);
make_generic ("bessel_y0", GFC_ISYM_Y0, GFC_STD_F2008);
add_sym_1 ("besy1", GFC_ISYM_Y1, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
gfc_check_fn_r, gfc_simplify_bessel_y1, gfc_resolve_g77_math1,
x, BT_REAL, dr, REQUIRED);
make_alias ("bessel_y1", GFC_STD_F2008);
add_sym_1 ("dbesy1", GFC_ISYM_Y1, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_GNU,
gfc_check_fn_d, gfc_simplify_bessel_y1, gfc_resolve_g77_math1,
x, BT_REAL, dd, REQUIRED);
make_generic ("bessel_y1", GFC_ISYM_Y1, GFC_STD_F2008);
add_sym_2 ("besyn", GFC_ISYM_YN, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
gfc_check_besn, gfc_simplify_bessel_yn, gfc_resolve_besn,
n, BT_INTEGER, di, REQUIRED, x, BT_REAL, dr, REQUIRED);
make_alias ("bessel_yn", GFC_STD_F2008);
add_sym_2 ("dbesyn", GFC_ISYM_YN, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_GNU,
gfc_check_besn, gfc_simplify_bessel_yn, gfc_resolve_besn,
n, BT_INTEGER, di, REQUIRED, x, BT_REAL, dd, REQUIRED);
add_sym_3 ("bessel_yn", GFC_ISYM_YN2, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F2008,
gfc_check_bessel_n2, gfc_simplify_bessel_yn2, gfc_resolve_bessel_n2,
"n1", BT_INTEGER, di, REQUIRED,"n2", BT_INTEGER, di, REQUIRED,
x, BT_REAL, dr, REQUIRED);
set_attr_value (3, true, true, true);
make_generic ("bessel_yn", GFC_ISYM_YN, GFC_STD_F2008);
add_sym_2 ("bge", GFC_ISYM_BGE, CLASS_ELEMENTAL, ACTUAL_NO,
BT_LOGICAL, dl, GFC_STD_F2008,
gfc_check_bge_bgt_ble_blt, gfc_simplify_bge, NULL,
i, BT_INTEGER, di, REQUIRED, j, BT_INTEGER, di, REQUIRED);
make_generic ("bge", GFC_ISYM_BGE, GFC_STD_F2008);
add_sym_2 ("bgt", GFC_ISYM_BGT, CLASS_ELEMENTAL, ACTUAL_NO,
BT_LOGICAL, dl, GFC_STD_F2008,
gfc_check_bge_bgt_ble_blt, gfc_simplify_bgt, NULL,
i, BT_INTEGER, di, REQUIRED, j, BT_INTEGER, di, REQUIRED);
make_generic ("bgt", GFC_ISYM_BGT, GFC_STD_F2008);
add_sym_1 ("bit_size", GFC_ISYM_BIT_SIZE, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
gfc_check_i, gfc_simplify_bit_size, NULL,
i, BT_INTEGER, di, REQUIRED);
make_generic ("bit_size", GFC_ISYM_BIT_SIZE, GFC_STD_F95);
add_sym_2 ("ble", GFC_ISYM_BLE, CLASS_ELEMENTAL, ACTUAL_NO,
BT_LOGICAL, dl, GFC_STD_F2008,
gfc_check_bge_bgt_ble_blt, gfc_simplify_ble, NULL,
i, BT_INTEGER, di, REQUIRED, j, BT_INTEGER, di, REQUIRED);
make_generic ("ble", GFC_ISYM_BLE, GFC_STD_F2008);
add_sym_2 ("blt", GFC_ISYM_BLT, CLASS_ELEMENTAL, ACTUAL_NO,
BT_LOGICAL, dl, GFC_STD_F2008,
gfc_check_bge_bgt_ble_blt, gfc_simplify_blt, NULL,
i, BT_INTEGER, di, REQUIRED, j, BT_INTEGER, di, REQUIRED);
make_generic ("blt", GFC_ISYM_BLT, GFC_STD_F2008);
add_sym_2 ("btest", GFC_ISYM_BTEST, CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F95,
gfc_check_bitfcn, gfc_simplify_btest, gfc_resolve_btest,
i, BT_INTEGER, di, REQUIRED, pos, BT_INTEGER, di, REQUIRED);
if (flag_dec_intrinsic_ints)
{
make_alias ("bbtest", GFC_STD_GNU);
make_alias ("bitest", GFC_STD_GNU);
make_alias ("bjtest", GFC_STD_GNU);
make_alias ("bktest", GFC_STD_GNU);
}
make_generic ("btest", GFC_ISYM_BTEST, GFC_STD_F95);
add_sym_2 ("ceiling", GFC_ISYM_CEILING, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
gfc_check_a_ikind, gfc_simplify_ceiling, gfc_resolve_ceiling,
a, BT_REAL, dr, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
make_generic ("ceiling", GFC_ISYM_CEILING, GFC_STD_F95);
add_sym_2 ("char", GFC_ISYM_CHAR, CLASS_ELEMENTAL, ACTUAL_NO, BT_CHARACTER, dc, GFC_STD_F77,
gfc_check_char, gfc_simplify_char, gfc_resolve_char,
i, BT_INTEGER, di, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
make_generic ("char", GFC_ISYM_CHAR, GFC_STD_F77);
add_sym_1 ("chdir", GFC_ISYM_CHDIR, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, di,
GFC_STD_GNU, gfc_check_chdir, NULL, gfc_resolve_chdir,
nm, BT_CHARACTER, dc, REQUIRED);
make_generic ("chdir", GFC_ISYM_CHDIR, GFC_STD_GNU);
add_sym_2 ("chmod", GFC_ISYM_CHMOD, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
di, GFC_STD_GNU, gfc_check_chmod, NULL, gfc_resolve_chmod,
nm, BT_CHARACTER, dc, REQUIRED, md, BT_CHARACTER, dc, REQUIRED);
make_generic ("chmod", GFC_ISYM_CHMOD, GFC_STD_GNU);
add_sym_3 ("cmplx", GFC_ISYM_CMPLX, CLASS_ELEMENTAL, ACTUAL_NO, BT_COMPLEX, dz, GFC_STD_F77,
gfc_check_cmplx, gfc_simplify_cmplx, gfc_resolve_cmplx,
x, BT_UNKNOWN, dr, REQUIRED, y, BT_UNKNOWN, dr, OPTIONAL,
kind, BT_INTEGER, di, OPTIONAL);
make_generic ("cmplx", GFC_ISYM_CMPLX, GFC_STD_F77);
add_sym_0 ("command_argument_count", GFC_ISYM_COMMAND_ARGUMENT_COUNT, CLASS_INQUIRY,
ACTUAL_NO, BT_INTEGER, di, GFC_STD_F2003, NULL, NULL, NULL);
make_generic ("command_argument_count", GFC_ISYM_COMMAND_ARGUMENT_COUNT,
GFC_STD_F2003);
add_sym_2 ("complex", GFC_ISYM_COMPLEX, CLASS_ELEMENTAL, ACTUAL_NO, BT_COMPLEX, dz, GFC_STD_GNU,
gfc_check_complex, gfc_simplify_complex, gfc_resolve_complex,
x, BT_UNKNOWN, dr, REQUIRED, y, BT_UNKNOWN, dr, REQUIRED);
make_generic ("complex", GFC_ISYM_COMPLEX, GFC_STD_GNU);
/* Making dcmplx a specific of cmplx causes cmplx to return a double
complex instead of the default complex. */
add_sym_2 ("dcmplx", GFC_ISYM_CMPLX, CLASS_ELEMENTAL, ACTUAL_NO, BT_COMPLEX, dd, GFC_STD_GNU,
gfc_check_dcmplx, gfc_simplify_dcmplx, gfc_resolve_dcmplx,
x, BT_REAL, dd, REQUIRED, y, BT_REAL, dd, OPTIONAL);
make_generic ("dcmplx", GFC_ISYM_CMPLX, GFC_STD_GNU);
add_sym_1 ("conjg", GFC_ISYM_CONJG, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dz, GFC_STD_F77,
gfc_check_fn_c, gfc_simplify_conjg, gfc_resolve_conjg,
z, BT_COMPLEX, dz, REQUIRED);
add_sym_1 ("dconjg", GFC_ISYM_CONJG, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dd, GFC_STD_GNU,
NULL, gfc_simplify_conjg, gfc_resolve_conjg,
z, BT_COMPLEX, dd, REQUIRED);
make_generic ("conjg", GFC_ISYM_CONJG, GFC_STD_F77);
add_sym_1 ("cos", GFC_ISYM_COS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
gfc_check_fn_rc, gfc_simplify_cos, gfc_resolve_cos,
x, BT_REAL, dr, REQUIRED);
add_sym_1 ("dcos", GFC_ISYM_COS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
gfc_check_fn_d, gfc_simplify_cos, gfc_resolve_cos,
x, BT_REAL, dd, REQUIRED);
add_sym_1 ("ccos", GFC_ISYM_COS, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dz, GFC_STD_F77,
NULL, gfc_simplify_cos, gfc_resolve_cos,
x, BT_COMPLEX, dz, REQUIRED);
add_sym_1 ("zcos", GFC_ISYM_COS, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dd, GFC_STD_GNU,
NULL, gfc_simplify_cos, gfc_resolve_cos,
x, BT_COMPLEX, dd, REQUIRED);
make_alias ("cdcos", GFC_STD_GNU);
make_generic ("cos", GFC_ISYM_COS, GFC_STD_F77);
add_sym_1 ("cosh", GFC_ISYM_COSH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
gfc_check_fn_rc2008, gfc_simplify_cosh, gfc_resolve_cosh,
x, BT_REAL, dr, REQUIRED);
add_sym_1 ("dcosh", GFC_ISYM_COSH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
gfc_check_fn_d, gfc_simplify_cosh, gfc_resolve_cosh,
x, BT_REAL, dd, REQUIRED);
make_generic ("cosh", GFC_ISYM_COSH, GFC_STD_F77);
add_sym_3 ("count", GFC_ISYM_COUNT, CLASS_TRANSFORMATIONAL, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_F95,
gfc_check_count, gfc_simplify_count, gfc_resolve_count,
msk, BT_LOGICAL, dl, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
kind, BT_INTEGER, di, OPTIONAL);
make_generic ("count", GFC_ISYM_COUNT, GFC_STD_F95);
add_sym_3 ("cshift", GFC_ISYM_CSHIFT, CLASS_TRANSFORMATIONAL, ACTUAL_NO,
BT_REAL, dr, GFC_STD_F95,
gfc_check_cshift, gfc_simplify_cshift, gfc_resolve_cshift,
ar, BT_REAL, dr, REQUIRED,
sh, BT_INTEGER, di, REQUIRED,
dm, BT_INTEGER, ii, OPTIONAL);
make_generic ("cshift", GFC_ISYM_CSHIFT, GFC_STD_F95);
add_sym_1 ("ctime", GFC_ISYM_CTIME, CLASS_IMPURE, ACTUAL_NO, BT_CHARACTER,
0, GFC_STD_GNU, gfc_check_ctime, NULL, gfc_resolve_ctime,
tm, BT_INTEGER, di, REQUIRED);
make_generic ("ctime", GFC_ISYM_CTIME, GFC_STD_GNU);
add_sym_1 ("dble", GFC_ISYM_DBLE, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_F77,
gfc_check_dble, gfc_simplify_dble, gfc_resolve_dble,
a, BT_REAL, dr, REQUIRED);
make_generic ("dble", GFC_ISYM_DBLE, GFC_STD_F77);
add_sym_1 ("digits", GFC_ISYM_DIGITS, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
gfc_check_digits, gfc_simplify_digits, NULL,
x, BT_UNKNOWN, dr, REQUIRED);
make_generic ("digits", GFC_ISYM_DIGITS, GFC_STD_F95);
add_sym_2 ("dim", GFC_ISYM_DIM, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
gfc_check_a_p, gfc_simplify_dim, gfc_resolve_dim,
x, BT_REAL, dr, REQUIRED, y, BT_REAL, dr, REQUIRED);
add_sym_2 ("idim", GFC_ISYM_DIM, CLASS_ELEMENTAL, ACTUAL_YES, BT_INTEGER, di, GFC_STD_F77,
NULL, gfc_simplify_dim, gfc_resolve_dim,
x, BT_INTEGER, di, REQUIRED, y, BT_INTEGER, di, REQUIRED);
add_sym_2 ("ddim", GFC_ISYM_DIM, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
gfc_check_x_yd, gfc_simplify_dim, gfc_resolve_dim,
x, BT_REAL, dd, REQUIRED, y, BT_REAL, dd, REQUIRED);
make_generic ("dim", GFC_ISYM_DIM, GFC_STD_F77);
add_sym_2 ("dot_product", GFC_ISYM_DOT_PRODUCT, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr,
GFC_STD_F95, gfc_check_dot_product, gfc_simplify_dot_product, gfc_resolve_dot_product,
va, BT_REAL, dr, REQUIRED, vb, BT_REAL, dr, REQUIRED);
make_generic ("dot_product", GFC_ISYM_DOT_PRODUCT, GFC_STD_F95);
add_sym_2 ("dprod", GFC_ISYM_DPROD,CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
gfc_check_dprod, gfc_simplify_dprod, gfc_resolve_dprod,
x, BT_REAL, dr, REQUIRED, y, BT_REAL, dr, REQUIRED);
make_generic ("dprod", GFC_ISYM_DPROD, GFC_STD_F77);
add_sym_1 ("dreal", GFC_ISYM_REAL, CLASS_ELEMENTAL, ACTUAL_NO,
BT_REAL, dd, GFC_STD_GNU, NULL, gfc_simplify_dreal, NULL,
a, BT_COMPLEX, dd, REQUIRED);
make_generic ("dreal", GFC_ISYM_REAL, GFC_STD_GNU);
add_sym_3 ("dshiftl", GFC_ISYM_DSHIFTL, CLASS_ELEMENTAL, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_F2008,
gfc_check_dshift, gfc_simplify_dshiftl, gfc_resolve_dshift,
i, BT_INTEGER, di, REQUIRED,
j, BT_INTEGER, di, REQUIRED,
sh, BT_INTEGER, di, REQUIRED);
make_generic ("dshiftl", GFC_ISYM_DSHIFTL, GFC_STD_F2008);
add_sym_3 ("dshiftr", GFC_ISYM_DSHIFTR, CLASS_ELEMENTAL, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_F2008,
gfc_check_dshift, gfc_simplify_dshiftr, gfc_resolve_dshift,
i, BT_INTEGER, di, REQUIRED,
j, BT_INTEGER, di, REQUIRED,
sh, BT_INTEGER, di, REQUIRED);
make_generic ("dshiftr", GFC_ISYM_DSHIFTR, GFC_STD_F2008);
add_sym_4 ("eoshift", GFC_ISYM_EOSHIFT, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
gfc_check_eoshift, gfc_simplify_eoshift, gfc_resolve_eoshift,
ar, BT_REAL, dr, REQUIRED, sh, BT_INTEGER, ii, REQUIRED,
bd, BT_REAL, dr, OPTIONAL, dm, BT_INTEGER, ii, OPTIONAL);
make_generic ("eoshift", GFC_ISYM_EOSHIFT, GFC_STD_F95);
add_sym_1 ("epsilon", GFC_ISYM_EPSILON, CLASS_INQUIRY, ACTUAL_NO, BT_REAL, dr,
GFC_STD_F95, gfc_check_fn_r, gfc_simplify_epsilon, NULL,
x, BT_REAL, dr, REQUIRED);
make_generic ("epsilon", GFC_ISYM_EPSILON, GFC_STD_F95);
/* G77 compatibility for the ERF() and ERFC() functions. */
add_sym_1 ("erf", GFC_ISYM_ERF, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr,
GFC_STD_F2008, gfc_check_fn_r, gfc_simplify_erf,
gfc_resolve_g77_math1, x, BT_REAL, dr, REQUIRED);
add_sym_1 ("derf", GFC_ISYM_ERF, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd,
GFC_STD_GNU, gfc_check_fn_d, gfc_simplify_erf,
gfc_resolve_g77_math1, x, BT_REAL, dd, REQUIRED);
make_generic ("erf", GFC_ISYM_ERF, GFC_STD_F2008);
add_sym_1 ("erfc", GFC_ISYM_ERFC, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr,
GFC_STD_F2008, gfc_check_fn_r, gfc_simplify_erfc,
gfc_resolve_g77_math1, x, BT_REAL, dr, REQUIRED);
add_sym_1 ("derfc", GFC_ISYM_ERFC, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd,
GFC_STD_GNU, gfc_check_fn_d, gfc_simplify_erfc,
gfc_resolve_g77_math1, x, BT_REAL, dd, REQUIRED);
make_generic ("erfc", GFC_ISYM_ERFC, GFC_STD_F2008);
add_sym_1 ("erfc_scaled", GFC_ISYM_ERFC_SCALED, CLASS_ELEMENTAL, ACTUAL_NO,
BT_REAL, dr, GFC_STD_F2008, gfc_check_fn_r,
gfc_simplify_erfc_scaled, gfc_resolve_g77_math1, x, BT_REAL,
dr, REQUIRED);
make_generic ("erfc_scaled", GFC_ISYM_ERFC_SCALED, GFC_STD_F2008);
/* G77 compatibility */
add_sym_1 ("dtime", GFC_ISYM_DTIME, CLASS_IMPURE, ACTUAL_NO, BT_REAL,
4, GFC_STD_GNU, gfc_check_dtime_etime, NULL, NULL,
x, BT_REAL, 4, REQUIRED);
make_generic ("dtime", GFC_ISYM_DTIME, GFC_STD_GNU);
add_sym_1 ("etime", GFC_ISYM_ETIME, CLASS_IMPURE, ACTUAL_NO, BT_REAL,
4, GFC_STD_GNU, gfc_check_dtime_etime, NULL, NULL,
x, BT_REAL, 4, REQUIRED);
make_generic ("etime", GFC_ISYM_ETIME, GFC_STD_GNU);
add_sym_1 ("exp", GFC_ISYM_EXP, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
gfc_check_fn_rc, gfc_simplify_exp, gfc_resolve_exp,
x, BT_REAL, dr, REQUIRED);
add_sym_1 ("dexp", GFC_ISYM_EXP, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
gfc_check_fn_d, gfc_simplify_exp, gfc_resolve_exp,
x, BT_REAL, dd, REQUIRED);
add_sym_1 ("cexp", GFC_ISYM_EXP, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dz, GFC_STD_F77,
NULL, gfc_simplify_exp, gfc_resolve_exp,
x, BT_COMPLEX, dz, REQUIRED);
add_sym_1 ("zexp", GFC_ISYM_EXP, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dd, GFC_STD_GNU,
NULL, gfc_simplify_exp, gfc_resolve_exp,
x, BT_COMPLEX, dd, REQUIRED);
make_alias ("cdexp", GFC_STD_GNU);
make_generic ("exp", GFC_ISYM_EXP, GFC_STD_F77);
add_sym_1 ("exponent", GFC_ISYM_EXPONENT, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di,
GFC_STD_F95, gfc_check_fn_r, gfc_simplify_exponent, gfc_resolve_exponent,
x, BT_REAL, dr, REQUIRED);
make_generic ("exponent", GFC_ISYM_EXPONENT, GFC_STD_F95);
add_sym_2 ("extends_type_of", GFC_ISYM_EXTENDS_TYPE_OF, CLASS_INQUIRY,
ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F2003,
gfc_check_same_type_as, gfc_simplify_extends_type_of,
gfc_resolve_extends_type_of,
a, BT_UNKNOWN, 0, REQUIRED,
mo, BT_UNKNOWN, 0, REQUIRED);
add_sym_2 ("failed_images", GFC_ISYM_FAILED_IMAGES, CLASS_TRANSFORMATIONAL,
ACTUAL_NO, BT_INTEGER, dd, GFC_STD_F2018,
gfc_check_failed_or_stopped_images,
gfc_simplify_failed_or_stopped_images,
gfc_resolve_failed_images, team, BT_VOID, di, OPTIONAL,
kind, BT_INTEGER, di, OPTIONAL);
add_sym_0 ("fdate", GFC_ISYM_FDATE, CLASS_IMPURE, ACTUAL_NO, BT_CHARACTER,
dc, GFC_STD_GNU, NULL, NULL, gfc_resolve_fdate);
make_generic ("fdate", GFC_ISYM_FDATE, GFC_STD_GNU);
add_sym_2 ("floor", GFC_ISYM_FLOOR, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
gfc_check_a_ikind, gfc_simplify_floor, gfc_resolve_floor,
a, BT_REAL, dr, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
make_generic ("floor", GFC_ISYM_FLOOR, GFC_STD_F95);
/* G77 compatible fnum */
add_sym_1 ("fnum", GFC_ISYM_FNUM, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
di, GFC_STD_GNU, gfc_check_fnum, NULL, gfc_resolve_fnum,
ut, BT_INTEGER, di, REQUIRED);
make_generic ("fnum", GFC_ISYM_FNUM, GFC_STD_GNU);
add_sym_1 ("fraction", GFC_ISYM_FRACTION, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr,
GFC_STD_F95, gfc_check_fn_r, gfc_simplify_fraction, gfc_resolve_fraction,
x, BT_REAL, dr, REQUIRED);
make_generic ("fraction", GFC_ISYM_FRACTION, GFC_STD_F95);
add_sym_2_intent ("fstat", GFC_ISYM_FSTAT, CLASS_IMPURE, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_GNU,
gfc_check_fstat, NULL, gfc_resolve_fstat,
ut, BT_INTEGER, di, REQUIRED, INTENT_IN,
vl, BT_INTEGER, di, REQUIRED, INTENT_OUT);
make_generic ("fstat", GFC_ISYM_FSTAT, GFC_STD_GNU);
add_sym_1 ("ftell", GFC_ISYM_FTELL, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
ii, GFC_STD_GNU, gfc_check_ftell, NULL, gfc_resolve_ftell,
ut, BT_INTEGER, di, REQUIRED);
make_generic ("ftell", GFC_ISYM_FTELL, GFC_STD_GNU);
add_sym_2_intent ("fgetc", GFC_ISYM_FGETC, CLASS_IMPURE, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_GNU,
gfc_check_fgetputc, NULL, gfc_resolve_fgetc,
ut, BT_INTEGER, di, REQUIRED, INTENT_IN,
c, BT_CHARACTER, dc, REQUIRED, INTENT_OUT);
make_generic ("fgetc", GFC_ISYM_FGETC, GFC_STD_GNU);
add_sym_1_intent ("fget", GFC_ISYM_FGET, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
di, GFC_STD_GNU, gfc_check_fgetput, NULL, gfc_resolve_fget,
c, BT_CHARACTER, dc, REQUIRED, INTENT_OUT);
make_generic ("fget", GFC_ISYM_FGET, GFC_STD_GNU);
add_sym_2 ("fputc", GFC_ISYM_FPUTC, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
di, GFC_STD_GNU, gfc_check_fgetputc, NULL, gfc_resolve_fputc,
ut, BT_INTEGER, di, REQUIRED, c, BT_CHARACTER, dc, REQUIRED);
make_generic ("fputc", GFC_ISYM_FPUTC, GFC_STD_GNU);
add_sym_1 ("fput", GFC_ISYM_FPUT, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
di, GFC_STD_GNU, gfc_check_fgetput, NULL, gfc_resolve_fput,
c, BT_CHARACTER, dc, REQUIRED);
make_generic ("fput", GFC_ISYM_FPUT, GFC_STD_GNU);
add_sym_1 ("gamma", GFC_ISYM_TGAMMA, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr,
GFC_STD_F2008, gfc_check_fn_r, gfc_simplify_gamma,
gfc_resolve_gamma, x, BT_REAL, dr, REQUIRED);
add_sym_1 ("dgamma", GFC_ISYM_TGAMMA, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
gfc_check_fn_d, gfc_simplify_gamma, gfc_resolve_gamma,
x, BT_REAL, dr, REQUIRED);
make_generic ("gamma", GFC_ISYM_TGAMMA, GFC_STD_F2008);
/* Unix IDs (g77 compatibility) */
add_sym_1 ("getcwd", GFC_ISYM_GETCWD, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
di, GFC_STD_GNU, NULL, NULL, gfc_resolve_getcwd,
c, BT_CHARACTER, dc, REQUIRED);
make_generic ("getcwd", GFC_ISYM_GETCWD, GFC_STD_GNU);
add_sym_0 ("getgid", GFC_ISYM_GETGID, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
di, GFC_STD_GNU, NULL, NULL, gfc_resolve_getgid);
make_generic ("getgid", GFC_ISYM_GETGID, GFC_STD_GNU);
add_sym_0 ("getpid", GFC_ISYM_GETPID, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
di, GFC_STD_GNU, NULL, NULL, gfc_resolve_getpid);
make_generic ("getpid", GFC_ISYM_GETPID, GFC_STD_GNU);
add_sym_1 ("get_team", GFC_ISYM_GET_TEAM, CLASS_TRANSFORMATIONAL,
ACTUAL_NO, BT_INTEGER, di, GFC_STD_F2018,
gfc_check_get_team, NULL, gfc_resolve_get_team,
level, BT_INTEGER, di, OPTIONAL);
add_sym_0 ("getuid", GFC_ISYM_GETUID, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
di, GFC_STD_GNU, NULL, NULL, gfc_resolve_getuid);
make_generic ("getuid", GFC_ISYM_GETUID, GFC_STD_GNU);
add_sym_1_intent ("hostnm", GFC_ISYM_HOSTNM, CLASS_IMPURE, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_GNU,
gfc_check_hostnm, NULL, gfc_resolve_hostnm,
c, BT_CHARACTER, dc, REQUIRED, INTENT_OUT);
make_generic ("hostnm", GFC_ISYM_HOSTNM, GFC_STD_GNU);
add_sym_1 ("huge", GFC_ISYM_HUGE, CLASS_INQUIRY, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
gfc_check_huge, gfc_simplify_huge, NULL,
x, BT_UNKNOWN, dr, REQUIRED);
make_generic ("huge", GFC_ISYM_HUGE, GFC_STD_F95);
add_sym_2 ("hypot", GFC_ISYM_HYPOT, CLASS_ELEMENTAL, ACTUAL_NO,
BT_REAL, dr, GFC_STD_F2008,
gfc_check_hypot, gfc_simplify_hypot, gfc_resolve_hypot,
x, BT_REAL, dr, REQUIRED, y, BT_REAL, dr, REQUIRED);
make_generic ("hypot", GFC_ISYM_HYPOT, GFC_STD_F2008);
add_sym_2 ("iachar", GFC_ISYM_IACHAR, CLASS_ELEMENTAL, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_F95,
gfc_check_ichar_iachar, gfc_simplify_iachar, gfc_resolve_iachar,
c, BT_CHARACTER, dc, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
make_generic ("iachar", GFC_ISYM_IACHAR, GFC_STD_F95);
add_sym_2 ("iand", GFC_ISYM_IAND, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di,
GFC_STD_F95,
gfc_check_iand_ieor_ior, gfc_simplify_iand, gfc_resolve_iand,
i, BT_INTEGER, di, REQUIRED, j, BT_INTEGER, di, REQUIRED);
if (flag_dec_intrinsic_ints)
{
make_alias ("biand", GFC_STD_GNU);
make_alias ("iiand", GFC_STD_GNU);
make_alias ("jiand", GFC_STD_GNU);
make_alias ("kiand", GFC_STD_GNU);
}
make_generic ("iand", GFC_ISYM_IAND, GFC_STD_F95);
add_sym_2 ("and", GFC_ISYM_AND, CLASS_IMPURE, ACTUAL_NO, BT_LOGICAL,
dl, GFC_STD_GNU, gfc_check_and, gfc_simplify_and, gfc_resolve_and,
i, BT_UNKNOWN, 0, REQUIRED, j, BT_UNKNOWN, 0, REQUIRED);
make_generic ("and", GFC_ISYM_AND, GFC_STD_GNU);
add_sym_3red ("iall", GFC_ISYM_IALL, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F2008,
gfc_check_transf_bit_intrins, gfc_simplify_iall, gfc_resolve_iall,
ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
msk, BT_LOGICAL, dl, OPTIONAL);
make_generic ("iall", GFC_ISYM_IALL, GFC_STD_F2008);
add_sym_3red ("iany", GFC_ISYM_IANY, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F2008,
gfc_check_transf_bit_intrins, gfc_simplify_iany, gfc_resolve_iany,
ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
msk, BT_LOGICAL, dl, OPTIONAL);
make_generic ("iany", GFC_ISYM_IANY, GFC_STD_F2008);
add_sym_0 ("iargc", GFC_ISYM_IARGC, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
di, GFC_STD_GNU, NULL, NULL, NULL);
make_generic ("iargc", GFC_ISYM_IARGC, GFC_STD_GNU);
add_sym_2 ("ibclr", GFC_ISYM_IBCLR, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
gfc_check_bitfcn, gfc_simplify_ibclr, gfc_resolve_ibclr,
i, BT_INTEGER, di, REQUIRED, pos, BT_INTEGER, di, REQUIRED);
if (flag_dec_intrinsic_ints)
{
make_alias ("bbclr", GFC_STD_GNU);
make_alias ("iibclr", GFC_STD_GNU);
make_alias ("jibclr", GFC_STD_GNU);
make_alias ("kibclr", GFC_STD_GNU);
}
make_generic ("ibclr", GFC_ISYM_IBCLR, GFC_STD_F95);
add_sym_3 ("ibits", GFC_ISYM_IBITS, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
gfc_check_ibits, gfc_simplify_ibits, gfc_resolve_ibits,
i, BT_INTEGER, di, REQUIRED, pos, BT_INTEGER, di, REQUIRED,
ln, BT_INTEGER, di, REQUIRED);
if (flag_dec_intrinsic_ints)
{
make_alias ("bbits", GFC_STD_GNU);
make_alias ("iibits", GFC_STD_GNU);
make_alias ("jibits", GFC_STD_GNU);
make_alias ("kibits", GFC_STD_GNU);
}
make_generic ("ibits", GFC_ISYM_IBITS, GFC_STD_F95);
add_sym_2 ("ibset", GFC_ISYM_IBSET, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
gfc_check_bitfcn, gfc_simplify_ibset, gfc_resolve_ibset,
i, BT_INTEGER, di, REQUIRED, pos, BT_INTEGER, di, REQUIRED);
if (flag_dec_intrinsic_ints)
{
make_alias ("bbset", GFC_STD_GNU);
make_alias ("iibset", GFC_STD_GNU);
make_alias ("jibset", GFC_STD_GNU);
make_alias ("kibset", GFC_STD_GNU);
}
make_generic ("ibset", GFC_ISYM_IBSET, GFC_STD_F95);
add_sym_2 ("ichar", GFC_ISYM_ICHAR, CLASS_ELEMENTAL, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_F77,
gfc_check_ichar_iachar, gfc_simplify_ichar, gfc_resolve_ichar,
c, BT_CHARACTER, dc, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
make_generic ("ichar", GFC_ISYM_ICHAR, GFC_STD_F77);
add_sym_2 ("ieor", GFC_ISYM_IEOR, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di,
GFC_STD_F95,
gfc_check_iand_ieor_ior, gfc_simplify_ieor, gfc_resolve_ieor,
i, BT_INTEGER, di, REQUIRED, j, BT_INTEGER, di, REQUIRED);
if (flag_dec_intrinsic_ints)
{
make_alias ("bieor", GFC_STD_GNU);
make_alias ("iieor", GFC_STD_GNU);
make_alias ("jieor", GFC_STD_GNU);
make_alias ("kieor", GFC_STD_GNU);
}
make_generic ("ieor", GFC_ISYM_IEOR, GFC_STD_F95);
add_sym_2 ("xor", GFC_ISYM_XOR, CLASS_IMPURE, ACTUAL_NO, BT_LOGICAL,
dl, GFC_STD_GNU, gfc_check_and, gfc_simplify_xor, gfc_resolve_xor,
i, BT_UNKNOWN, 0, REQUIRED, j, BT_UNKNOWN, 0, REQUIRED);
make_generic ("xor", GFC_ISYM_XOR, GFC_STD_GNU);
add_sym_0 ("ierrno", GFC_ISYM_IERRNO, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
di, GFC_STD_GNU, NULL, NULL, gfc_resolve_ierrno);
make_generic ("ierrno", GFC_ISYM_IERRNO, GFC_STD_GNU);
add_sym_2 ("image_index", GFC_ISYM_IMAGE_INDEX, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F2008,
gfc_check_image_index, gfc_simplify_image_index, gfc_resolve_image_index,
ca, BT_REAL, dr, REQUIRED, sub, BT_INTEGER, ii, REQUIRED);
add_sym_2 ("image_status", GFC_ISYM_IMAGE_STATUS, CLASS_ELEMENTAL, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_F2018, gfc_check_image_status,
gfc_simplify_image_status, gfc_resolve_image_status, image,
BT_INTEGER, di, REQUIRED, team, BT_VOID, di, OPTIONAL);
/* The resolution function for INDEX is called gfc_resolve_index_func
because the name gfc_resolve_index is already used in resolve.c. */
add_sym_4ind ("index", GFC_ISYM_INDEX, CLASS_ELEMENTAL, ACTUAL_YES,
BT_INTEGER, di, GFC_STD_F77,
gfc_check_index, gfc_simplify_index, gfc_resolve_index_func,
stg, BT_CHARACTER, dc, REQUIRED, ssg, BT_CHARACTER, dc, REQUIRED,
bck, BT_LOGICAL, dl, OPTIONAL, kind, BT_INTEGER, di, OPTIONAL);
make_generic ("index", GFC_ISYM_INDEX, GFC_STD_F77);
add_sym_2 ("int", GFC_ISYM_INT, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F77,
gfc_check_int, gfc_simplify_int, gfc_resolve_int,
a, BT_REAL, dr, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
add_sym_1 ("ifix", GFC_ISYM_INT, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F77,
NULL, gfc_simplify_ifix, NULL,
a, BT_REAL, dr, REQUIRED);
add_sym_1 ("idint", GFC_ISYM_INT, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F77,
NULL, gfc_simplify_idint, NULL,
a, BT_REAL, dd, REQUIRED);
make_generic ("int", GFC_ISYM_INT, GFC_STD_F77);
add_sym_1 ("int2", GFC_ISYM_INT2, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU,
gfc_check_intconv, gfc_simplify_int2, gfc_resolve_int2,
a, BT_REAL, dr, REQUIRED);
make_alias ("short", GFC_STD_GNU);
make_generic ("int2", GFC_ISYM_INT2, GFC_STD_GNU);
add_sym_1 ("int8", GFC_ISYM_INT8, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU,
gfc_check_intconv, gfc_simplify_int8, gfc_resolve_int8,
a, BT_REAL, dr, REQUIRED);
make_generic ("int8", GFC_ISYM_INT8, GFC_STD_GNU);
add_sym_1 ("long", GFC_ISYM_LONG, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU,
gfc_check_intconv, gfc_simplify_long, gfc_resolve_long,
a, BT_REAL, dr, REQUIRED);
make_generic ("long", GFC_ISYM_LONG, GFC_STD_GNU);
add_sym_2 ("ior", GFC_ISYM_IOR, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di,
GFC_STD_F95,
gfc_check_iand_ieor_ior, gfc_simplify_ior, gfc_resolve_ior,
i, BT_INTEGER, di, REQUIRED, j, BT_INTEGER, di, REQUIRED);
if (flag_dec_intrinsic_ints)
{
make_alias ("bior", GFC_STD_GNU);
make_alias ("iior", GFC_STD_GNU);
make_alias ("jior", GFC_STD_GNU);
make_alias ("kior", GFC_STD_GNU);
}
make_generic ("ior", GFC_ISYM_IOR, GFC_STD_F95);
add_sym_2 ("or", GFC_ISYM_OR, CLASS_IMPURE, ACTUAL_NO, BT_LOGICAL,
dl, GFC_STD_GNU, gfc_check_and, gfc_simplify_or, gfc_resolve_or,
i, BT_UNKNOWN, 0, REQUIRED, j, BT_UNKNOWN, 0, REQUIRED);
make_generic ("or", GFC_ISYM_OR, GFC_STD_GNU);
add_sym_3red ("iparity", GFC_ISYM_IPARITY, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F2008,
gfc_check_transf_bit_intrins, gfc_simplify_iparity, gfc_resolve_iparity,
ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
msk, BT_LOGICAL, dl, OPTIONAL);
make_generic ("iparity", GFC_ISYM_IPARITY, GFC_STD_F2008);
/* The following function is for G77 compatibility. */
add_sym_1 ("irand", GFC_ISYM_IRAND, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
4, GFC_STD_GNU, gfc_check_irand, NULL, NULL,
i, BT_INTEGER, 4, OPTIONAL);
make_generic ("irand", GFC_ISYM_IRAND, GFC_STD_GNU);
add_sym_1 ("isatty", GFC_ISYM_ISATTY, CLASS_IMPURE, ACTUAL_NO, BT_LOGICAL,
dl, GFC_STD_GNU, gfc_check_isatty, NULL, gfc_resolve_isatty,
ut, BT_INTEGER, di, REQUIRED);
make_generic ("isatty", GFC_ISYM_ISATTY, GFC_STD_GNU);
add_sym_1 ("is_contiguous", GFC_ISYM_IS_CONTIGUOUS, CLASS_INQUIRY, ACTUAL_NO,
BT_LOGICAL, dl, GFC_STD_F2008,
gfc_check_is_contiguous, gfc_simplify_is_contiguous,
gfc_resolve_is_contiguous,
ar, BT_REAL, dr, REQUIRED);
make_generic ("is_contiguous", GFC_ISYM_IS_CONTIGUOUS, GFC_STD_F2008);
add_sym_1 ("is_iostat_end", GFC_ISYM_IS_IOSTAT_END,
CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F2003,
gfc_check_i, gfc_simplify_is_iostat_end, NULL,
i, BT_INTEGER, 0, REQUIRED);
make_generic ("is_iostat_end", GFC_ISYM_IS_IOSTAT_END, GFC_STD_F2003);
add_sym_1 ("is_iostat_eor", GFC_ISYM_IS_IOSTAT_EOR,
CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F2003,
gfc_check_i, gfc_simplify_is_iostat_eor, NULL,
i, BT_INTEGER, 0, REQUIRED);
make_generic ("is_iostat_eor", GFC_ISYM_IS_IOSTAT_EOR, GFC_STD_F2003);
add_sym_1 ("isnan", GFC_ISYM_ISNAN, CLASS_ELEMENTAL, ACTUAL_NO,
BT_LOGICAL, dl, GFC_STD_GNU,
gfc_check_isnan, gfc_simplify_isnan, NULL,
x, BT_REAL, 0, REQUIRED);
make_generic ("isnan", GFC_ISYM_ISNAN, GFC_STD_GNU);
add_sym_2 ("rshift", GFC_ISYM_RSHIFT, CLASS_ELEMENTAL, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_GNU,
gfc_check_ishft, gfc_simplify_rshift, gfc_resolve_rshift,
i, BT_INTEGER, di, REQUIRED, sh, BT_INTEGER, di, REQUIRED);
make_generic ("rshift", GFC_ISYM_RSHIFT, GFC_STD_GNU);
add_sym_2 ("lshift", GFC_ISYM_LSHIFT, CLASS_ELEMENTAL, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_GNU,
gfc_check_ishft, gfc_simplify_lshift, gfc_resolve_lshift,
i, BT_INTEGER, di, REQUIRED, sh, BT_INTEGER, di, REQUIRED);
make_generic ("lshift", GFC_ISYM_LSHIFT, GFC_STD_GNU);
add_sym_2 ("ishft", GFC_ISYM_ISHFT, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
gfc_check_ishft, gfc_simplify_ishft, gfc_resolve_ishft,
i, BT_INTEGER, di, REQUIRED, sh, BT_INTEGER, di, REQUIRED);
if (flag_dec_intrinsic_ints)
{
make_alias ("bshft", GFC_STD_GNU);
make_alias ("iishft", GFC_STD_GNU);
make_alias ("jishft", GFC_STD_GNU);
make_alias ("kishft", GFC_STD_GNU);
}
make_generic ("ishft", GFC_ISYM_ISHFT, GFC_STD_F95);
add_sym_3 ("ishftc", GFC_ISYM_ISHFTC, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
gfc_check_ishftc, gfc_simplify_ishftc, gfc_resolve_ishftc,
i, BT_INTEGER, di, REQUIRED, sh, BT_INTEGER, di, REQUIRED,
sz, BT_INTEGER, di, OPTIONAL);
if (flag_dec_intrinsic_ints)
{
make_alias ("bshftc", GFC_STD_GNU);
make_alias ("iishftc", GFC_STD_GNU);
make_alias ("jishftc", GFC_STD_GNU);
make_alias ("kishftc", GFC_STD_GNU);
}
make_generic ("ishftc", GFC_ISYM_ISHFTC, GFC_STD_F95);
add_sym_2 ("kill", GFC_ISYM_KILL, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
di, GFC_STD_GNU, gfc_check_kill, NULL, NULL,
pid, BT_INTEGER, di, REQUIRED, sig, BT_INTEGER, di, REQUIRED);
make_generic ("kill", GFC_ISYM_KILL, GFC_STD_GNU);
add_sym_1 ("kind", GFC_ISYM_KIND, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
gfc_check_kind, gfc_simplify_kind, NULL,
x, BT_REAL, dr, REQUIRED);
make_generic ("kind", GFC_ISYM_KIND, GFC_STD_F95);
add_sym_3 ("lbound", GFC_ISYM_LBOUND, CLASS_INQUIRY, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_F95,
gfc_check_lbound, gfc_simplify_lbound, gfc_resolve_lbound,
ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, di, OPTIONAL,
kind, BT_INTEGER, di, OPTIONAL);
make_generic ("lbound", GFC_ISYM_LBOUND, GFC_STD_F95);
add_sym_3 ("lcobound", GFC_ISYM_LCOBOUND, CLASS_INQUIRY, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_F2008,
gfc_check_lcobound, gfc_simplify_lcobound, gfc_resolve_lcobound,
ca, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
kind, BT_INTEGER, di, OPTIONAL);
make_generic ("lcobound", GFC_ISYM_LCOBOUND, GFC_STD_F2008);
add_sym_1 ("leadz", GFC_ISYM_LEADZ, CLASS_ELEMENTAL, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_F2008,
gfc_check_i, gfc_simplify_leadz, NULL,
i, BT_INTEGER, di, REQUIRED);
make_generic ("leadz", GFC_ISYM_LEADZ, GFC_STD_F2008);
add_sym_2 ("len", GFC_ISYM_LEN, CLASS_INQUIRY, ACTUAL_YES,
BT_INTEGER, di, GFC_STD_F77,
gfc_check_len_lentrim, gfc_simplify_len, gfc_resolve_len,
stg, BT_CHARACTER, dc, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
make_generic ("len", GFC_ISYM_LEN, GFC_STD_F77);
add_sym_2 ("len_trim", GFC_ISYM_LEN_TRIM, CLASS_ELEMENTAL, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_F95,
gfc_check_len_lentrim, gfc_simplify_len_trim, gfc_resolve_len_trim,
stg, BT_CHARACTER, dc, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
make_alias ("lnblnk", GFC_STD_GNU);
make_generic ("len_trim", GFC_ISYM_LEN_TRIM, GFC_STD_F95);
add_sym_1 ("lgamma", GFC_ISYM_LGAMMA, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL,
dr, GFC_STD_GNU,
gfc_check_fn_r, gfc_simplify_lgamma, gfc_resolve_lgamma,
x, BT_REAL, dr, REQUIRED);
make_alias ("log_gamma", GFC_STD_F2008);
add_sym_1 ("algama", GFC_ISYM_LGAMMA, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
gfc_check_fn_r, gfc_simplify_lgamma, gfc_resolve_lgamma,
x, BT_REAL, dr, REQUIRED);
add_sym_1 ("dlgama", GFC_ISYM_LGAMMA, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
gfc_check_fn_d, gfc_simplify_lgamma, gfc_resolve_lgamma,
x, BT_REAL, dr, REQUIRED);
make_generic ("log_gamma", GFC_ISYM_LGAMMA, GFC_STD_F2008);
add_sym_2 ("lge", GFC_ISYM_LGE, CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl,
GFC_STD_F77, gfc_check_lge_lgt_lle_llt, gfc_simplify_lge, NULL,
sta, BT_CHARACTER, dc, REQUIRED, stb, BT_CHARACTER, dc, REQUIRED);
make_generic ("lge", GFC_ISYM_LGE, GFC_STD_F77);
add_sym_2 ("lgt", GFC_ISYM_LGT, CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl,
GFC_STD_F77, gfc_check_lge_lgt_lle_llt, gfc_simplify_lgt, NULL,
sta, BT_CHARACTER, dc, REQUIRED, stb, BT_CHARACTER, dc, REQUIRED);
make_generic ("lgt", GFC_ISYM_LGT, GFC_STD_F77);
add_sym_2 ("lle",GFC_ISYM_LLE, CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl,
GFC_STD_F77, gfc_check_lge_lgt_lle_llt, gfc_simplify_lle, NULL,
sta, BT_CHARACTER, dc, REQUIRED, stb, BT_CHARACTER, dc, REQUIRED);
make_generic ("lle", GFC_ISYM_LLE, GFC_STD_F77);
add_sym_2 ("llt", GFC_ISYM_LLT, CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl,
GFC_STD_F77, gfc_check_lge_lgt_lle_llt, gfc_simplify_llt, NULL,
sta, BT_CHARACTER, dc, REQUIRED, stb, BT_CHARACTER, dc, REQUIRED);
make_generic ("llt", GFC_ISYM_LLT, GFC_STD_F77);
add_sym_2 ("link", GFC_ISYM_LINK, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, di,
GFC_STD_GNU, gfc_check_link, NULL, gfc_resolve_link,
p1, BT_CHARACTER, dc, REQUIRED, p2, BT_CHARACTER, dc, REQUIRED);
make_generic ("link", GFC_ISYM_LINK, GFC_STD_GNU);
add_sym_1 ("log", GFC_ISYM_LOG, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F77,
gfc_check_fn_rc, gfc_simplify_log, gfc_resolve_log,
x, BT_REAL, dr, REQUIRED);
add_sym_1 ("alog", GFC_ISYM_LOG, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
NULL, gfc_simplify_log, gfc_resolve_log,
x, BT_REAL, dr, REQUIRED);
add_sym_1 ("dlog", GFC_ISYM_LOG, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
gfc_check_fn_d, gfc_simplify_log, gfc_resolve_log,
x, BT_REAL, dd, REQUIRED);
add_sym_1 ("clog", GFC_ISYM_LOG, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dz, GFC_STD_F77,
NULL, gfc_simplify_log, gfc_resolve_log,
x, BT_COMPLEX, dz, REQUIRED);
add_sym_1 ("zlog", GFC_ISYM_LOG, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dd, GFC_STD_GNU,
NULL, gfc_simplify_log, gfc_resolve_log,
x, BT_COMPLEX, dd, REQUIRED);
make_alias ("cdlog", GFC_STD_GNU);
make_generic ("log", GFC_ISYM_LOG, GFC_STD_F77);
add_sym_1 ("log10", GFC_ISYM_LOG10, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F77,
gfc_check_fn_r, gfc_simplify_log10, gfc_resolve_log10,
x, BT_REAL, dr, REQUIRED);
add_sym_1 ("alog10", GFC_ISYM_LOG10, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
NULL, gfc_simplify_log10, gfc_resolve_log10,
x, BT_REAL, dr, REQUIRED);
add_sym_1 ("dlog10", GFC_ISYM_LOG10, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
gfc_check_fn_d, gfc_simplify_log10, gfc_resolve_log10,
x, BT_REAL, dd, REQUIRED);
make_generic ("log10", GFC_ISYM_LOG10, GFC_STD_F77);
add_sym_2 ("logical", GFC_ISYM_LOGICAL, CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F95,
gfc_check_logical, gfc_simplify_logical, gfc_resolve_logical,
l, BT_LOGICAL, dl, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
make_generic ("logical", GFC_ISYM_LOGICAL, GFC_STD_F95);
add_sym_2_intent ("lstat", GFC_ISYM_LSTAT, CLASS_IMPURE, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_GNU,
gfc_check_stat, NULL, gfc_resolve_lstat,
nm, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
vl, BT_INTEGER, di, REQUIRED, INTENT_OUT);
make_generic ("lstat", GFC_ISYM_LSTAT, GFC_STD_GNU);
add_sym_1 ("malloc", GFC_ISYM_MALLOC, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, ii,
GFC_STD_GNU, gfc_check_malloc, NULL, NULL,
sz, BT_INTEGER, di, REQUIRED);
make_generic ("malloc", GFC_ISYM_MALLOC, GFC_STD_GNU);
add_sym_2 ("maskl", GFC_ISYM_MASKL, CLASS_ELEMENTAL, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_F2008,
gfc_check_mask, gfc_simplify_maskl, gfc_resolve_mask,
i, BT_INTEGER, di, REQUIRED,
kind, BT_INTEGER, di, OPTIONAL);
make_generic ("maskl", GFC_ISYM_MASKL, GFC_STD_F2008);
add_sym_2 ("maskr", GFC_ISYM_MASKR, CLASS_ELEMENTAL, ACTUAL_NO,
BT_INTEGER, di, GFC_STD_F2008,
gfc_check_mask, gfc_simplify_maskr, gfc_resolve_mask,
i, BT_INTEGER, di, REQUIRED,
kind, BT_INTEGER, di, OPTIONAL);
make_generic ("maskr", GFC_ISYM_MASKR, GFC_STD_F2008);
add_sym_2 ("matmul", GFC_ISYM_MATMUL, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
gfc_check_matmul, gfc_simplify_matmul, gfc_resolve_matmul,
ma, BT_REAL, dr</