X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ffortran%2Fintrinsic.c;h=38bcb273fdd146b31ab42ca9739fe98d47921c3e;hb=071be23809d255227730595ebfae85181b744ac8;hp=0c5c17733325723b08d77e7dc4d25084e5d3a591;hpb=5ef4af82b73d491288c136102710a80b4b649cb9;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/fortran/intrinsic.c b/gcc/fortran/intrinsic.c index 0c5c1773332..38bcb273fdd 100644 --- a/gcc/fortran/intrinsic.c +++ b/gcc/fortran/intrinsic.c @@ -1,6 +1,7 @@ /* Build up a list of intrinsic subroutines and functions for the name-resolution stage. - Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 + Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, + 2009, 2010, 2011 Free Software Foundation, Inc. Contributed by Andy Vaught & Katherine Holcomb @@ -29,26 +30,28 @@ along with GCC; see the file COPYING3. If not see /* Namespace to hold the resolved symbols for intrinsic subroutines. */ static gfc_namespace *gfc_intrinsic_namespace; -int gfc_init_expr = 0; +bool gfc_init_expr_flag = false; /* Pointers to an intrinsic function and its argument names that are being checked. */ const char *gfc_current_intrinsic; -const char *gfc_current_intrinsic_arg[MAX_INTRINSIC_ARGS]; +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; +static int nfunc, nsub, nargs, nconv, ncharconv; static enum { SZ_NOTHING = 0, SZ_SUBS, SZ_FUNCS, SZ_CONVS } sizing; -enum class -{ NO_CLASS = 0, CLASS_ELEMENTAL, CLASS_INQUIRY, CLASS_TRANSFORMATIONAL }; +enum klass +{ CLASS_IMPURE = 0, CLASS_PURE, CLASS_ELEMENTAL, + CLASS_INQUIRY, CLASS_TRANSFORMATIONAL, CLASS_ATOMIC }; #define ACTUAL_NO 0 #define ACTUAL_YES 1 @@ -96,7 +99,8 @@ gfc_type_letter (bt type) } -/* Get a symbol for a resolved name. */ +/* 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) @@ -109,6 +113,8 @@ gfc_get_intrinsic_sub_symbol (const char *name) sym->attr.flavor = FL_PROCEDURE; sym->attr.proc = PROC_INTRINSIC; + gfc_commit_symbol (sym); + return sym; } @@ -147,11 +153,33 @@ find_conv (gfc_typespec *from, gfc_typespec *to) } +/* 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; +} + + /* 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 try +static gfc_try do_check (gfc_intrinsic_sym *specific, gfc_actual_arglist *arg) { gfc_expr *a1, *a2, *a3, *a4, *a5; @@ -203,11 +231,12 @@ do_check (gfc_intrinsic_sym *specific, gfc_actual_arglist *arg) simplify pointer to simplification function resolve pointer to resolution function - Optional arguments come in multiples of four: - char * name of argument - bt type of argument - int kind of argument - int arg optional flag (1=optional, 0=required) + 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. @@ -219,12 +248,13 @@ do_check (gfc_intrinsic_sym *specific, gfc_actual_arglist *arg) ZABS ZCOS ZEXP ZLOG ZSIN ZSQRT. */ static void -add_sym (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt type, int kind, +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) @@ -244,6 +274,7 @@ add_sym (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt type strcat (buf, name); next_sym->lib_name = gfc_get_string (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); @@ -277,6 +308,7 @@ add_sym (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt type 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++; @@ -295,6 +327,8 @@ add_sym (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt type next_arg->ts.type = type; next_arg->ts.kind = kind; next_arg->optional = optional; + next_arg->value = 0; + next_arg->intent = intent; } } @@ -308,9 +342,9 @@ add_sym (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt type 0 arguments. */ static void -add_sym_0 (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt type, +add_sym_0 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type, int kind, int standard, - try (*check) (void), + gfc_try (*check) (void), gfc_expr *(*simplify) (void), void (*resolve) (gfc_expr *)) { @@ -331,7 +365,8 @@ add_sym_0 (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt ty 0 arguments. */ static void -add_sym_0s (const char *name, gfc_isym_id id, int standard, void (*resolve) (gfc_code *)) +add_sym_0s (const char *name, gfc_isym_id id, int standard, + void (*resolve) (gfc_code *)) { gfc_check_f cf; gfc_simplify_f sf; @@ -341,8 +376,8 @@ add_sym_0s (const char *name, gfc_isym_id id, int standard, void (*resolve) (gfc sf.f1 = NULL; rf.s1 = resolve; - add_sym (name, id, NO_CLASS, ACTUAL_NO, BT_UNKNOWN, 0, standard, cf, sf, rf, - (void *) 0); + add_sym (name, id, CLASS_IMPURE, ACTUAL_NO, BT_UNKNOWN, 0, standard, cf, sf, + rf, (void *) 0); } @@ -350,9 +385,9 @@ add_sym_0s (const char *name, gfc_isym_id id, int standard, void (*resolve) (gfc 1 arguments. */ static void -add_sym_1 (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt type, +add_sym_1 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type, int kind, int standard, - try (*check) (gfc_expr *), + gfc_try (*check) (gfc_expr *), gfc_expr *(*simplify) (gfc_expr *), void (*resolve) (gfc_expr *, gfc_expr *), const char *a1, bt type1, int kind1, int optional1) @@ -366,20 +401,46 @@ add_sym_1 (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt ty rf.f1 = resolve; add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf, - a1, type1, kind1, optional1, + 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, + gfc_try (*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. */ + 1 arguments, specifying the intent of the argument. */ static void -add_sym_1s (const char *name, gfc_isym_id id, enum class cl, bt type, int kind, int standard, - try (*check) (gfc_expr *), - gfc_expr *(*simplify) (gfc_expr *), - void (*resolve) (gfc_code *), - const char *a1, bt type1, int kind1, int optional1) +add_sym_1s (const char *name, gfc_isym_id id, enum klass cl, bt type, int kind, + int standard, gfc_try (*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; @@ -390,7 +451,7 @@ add_sym_1s (const char *name, gfc_isym_id id, enum class cl, bt type, int kind, rf.s1 = resolve; add_sym (name, id, cl, ACTUAL_NO, type, kind, standard, cf, sf, rf, - a1, type1, kind1, optional1, + a1, type1, kind1, optional1, intent1, (void *) 0); } @@ -399,9 +460,9 @@ add_sym_1s (const char *name, gfc_isym_id id, enum class cl, bt type, int kind, function. MAX et al take 2 or more arguments. */ static void -add_sym_1m (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt type, +add_sym_1m (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type, int kind, int standard, - try (*check) (gfc_actual_arglist *), + gfc_try (*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, @@ -416,8 +477,8 @@ add_sym_1m (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt t rf.f1m = resolve; add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf, - a1, type1, kind1, optional1, - a2, type2, kind2, optional2, + a1, type1, kind1, optional1, INTENT_IN, + a2, type2, kind2, optional2, INTENT_IN, (void *) 0); } @@ -426,9 +487,9 @@ add_sym_1m (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt t 2 arguments. */ static void -add_sym_2 (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt type, +add_sym_2 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type, int kind, int standard, - try (*check) (gfc_expr *, gfc_expr *), + gfc_try (*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, @@ -443,22 +504,52 @@ add_sym_2 (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt ty rf.f2 = resolve; add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf, - a1, type1, kind1, optional1, - a2, type2, kind2, optional2, + 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, + gfc_try (*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. */ + 2 arguments, specifying the intent of the arguments. */ static void -add_sym_2s (const char *name, gfc_isym_id id, enum class cl, bt type, int kind, int standard, - try (*check) (gfc_expr *, gfc_expr *), +add_sym_2s (const char *name, gfc_isym_id id, enum klass cl, bt type, + int kind, int standard, + gfc_try (*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, - const char *a2, bt type2, int kind2, int optional2) + sym_intent intent1, const char *a2, bt type2, int kind2, + int optional2, sym_intent intent2) { gfc_check_f cf; gfc_simplify_f sf; @@ -469,8 +560,8 @@ add_sym_2s (const char *name, gfc_isym_id id, enum class cl, bt type, int kind, rf.s1 = resolve; add_sym (name, id, cl, ACTUAL_NO, type, kind, standard, cf, sf, rf, - a1, type1, kind1, optional1, - a2, type2, kind2, optional2, + a1, type1, kind1, optional1, intent1, + a2, type2, kind2, optional2, intent2, (void *) 0); } @@ -479,9 +570,9 @@ add_sym_2s (const char *name, gfc_isym_id id, enum class cl, bt type, int kind, 3 arguments. */ static void -add_sym_3 (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt type, +add_sym_3 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type, int kind, int standard, - try (*check) (gfc_expr *, gfc_expr *, gfc_expr *), + gfc_try (*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, @@ -497,9 +588,9 @@ add_sym_3 (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt ty rf.f3 = resolve; add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf, - a1, type1, kind1, optional1, - a2, type2, kind2, optional2, - a3, type3, kind3, optional3, + a1, type1, kind1, optional1, INTENT_IN, + a2, type2, kind2, optional2, INTENT_IN, + a3, type3, kind3, optional3, INTENT_IN, (void *) 0); } @@ -508,9 +599,9 @@ add_sym_3 (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt ty might have to be reordered. */ static void -add_sym_3ml (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt type, +add_sym_3ml (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type, int kind, int standard, - try (*check) (gfc_actual_arglist *), + gfc_try (*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, @@ -526,9 +617,9 @@ add_sym_3ml (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt rf.f3 = resolve; add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf, - a1, type1, kind1, optional1, - a2, type2, kind2, optional2, - a3, type3, kind3, optional3, + a1, type1, kind1, optional1, INTENT_IN, + a2, type2, kind2, optional2, INTENT_IN, + a3, type3, kind3, optional3, INTENT_IN, (void *) 0); } @@ -537,9 +628,9 @@ add_sym_3ml (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt their argument also might have to be reordered. */ static void -add_sym_3red (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt type, +add_sym_3red (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type, int kind, int standard, - try (*check) (gfc_actual_arglist *), + gfc_try (*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, @@ -555,24 +646,26 @@ add_sym_3red (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt rf.f3 = resolve; add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf, - a1, type1, kind1, optional1, - a2, type2, kind2, optional2, - a3, type3, kind3, optional3, + 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. */ + 3 arguments, specifying the intent of the arguments. */ static void -add_sym_3s (const char *name, gfc_isym_id id, enum class cl, bt type, int kind, int standard, - try (*check) (gfc_expr *, gfc_expr *, gfc_expr *), +add_sym_3s (const char *name, gfc_isym_id id, enum klass cl, bt type, + int kind, int standard, + gfc_try (*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, - const char *a2, bt type2, int kind2, int optional2, - const char *a3, bt type3, int kind3, int optional3) + 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; @@ -583,9 +676,9 @@ add_sym_3s (const char *name, gfc_isym_id id, enum class cl, bt type, int kind, rf.s1 = resolve; add_sym (name, id, cl, ACTUAL_NO, type, kind, standard, cf, sf, rf, - a1, type1, kind1, optional1, - a2, type2, kind2, optional2, - a3, type3, kind3, optional3, + a1, type1, kind1, optional1, intent1, + a2, type2, kind2, optional2, intent2, + a3, type3, kind3, optional3, intent3, (void *) 0); } @@ -594,9 +687,9 @@ add_sym_3s (const char *name, gfc_isym_id id, enum class cl, bt type, int kind, 4 arguments. */ static void -add_sym_4 (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt type, +add_sym_4 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type, int kind, int standard, - try (*check) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *), + gfc_try (*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 *, @@ -615,10 +708,10 @@ add_sym_4 (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt ty rf.f4 = resolve; add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf, - a1, type1, kind1, optional1, - a2, type2, kind2, optional2, - a3, type3, kind3, optional3, - a4, type4, kind4, optional4, + 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); } @@ -627,15 +720,17 @@ add_sym_4 (const char *name, gfc_isym_id id, enum class cl, int actual_ok, bt ty 4 arguments. */ static void -add_sym_4s (const char *name, gfc_isym_id id, enum class cl, bt type, int kind, int standard, - try (*check) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *), +add_sym_4s (const char *name, gfc_isym_id id, enum klass cl, bt type, int kind, + int standard, + gfc_try (*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, - 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) + 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; @@ -646,10 +741,10 @@ add_sym_4s (const char *name, gfc_isym_id id, enum class cl, bt type, int kind, rf.s1 = resolve; add_sym (name, id, cl, ACTUAL_NO, type, kind, standard, cf, sf, rf, - a1, type1, kind1, optional1, - a2, type2, kind2, optional2, - a3, type3, kind3, optional3, - a4, type4, kind4, optional4, + a1, type1, kind1, optional1, intent1, + a2, type2, kind2, optional2, intent2, + a3, type3, kind3, optional3, intent3, + a4, type4, kind4, optional4, intent4, (void *) 0); } @@ -658,17 +753,20 @@ add_sym_4s (const char *name, gfc_isym_id id, enum class cl, bt type, int kind, 5 arguments. */ static void -add_sym_5s (const char *name, gfc_isym_id id, enum class cl, bt type, int kind, int standard, - try (*check) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *, +add_sym_5s (const char *name, gfc_isym_id id, enum klass cl, bt type, int kind, + int standard, + gfc_try (*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, - 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) + 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; @@ -679,11 +777,11 @@ add_sym_5s (const char *name, gfc_isym_id id, enum class cl, bt type, int kind, rf.s1 = resolve; add_sym (name, id, cl, ACTUAL_NO, type, kind, standard, cf, sf, rf, - a1, type1, kind1, optional1, - a2, type2, kind2, optional2, - a3, type3, kind3, optional3, - a4, type4, kind4, optional4, - a5, type5, kind5, optional5, + 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); } @@ -713,6 +811,24 @@ find_sym (gfc_intrinsic_sym *start, int n, const char *name) } +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. */ @@ -722,10 +838,10 @@ gfc_find_function (const char *name) gfc_intrinsic_sym *sym; sym = find_sym (functions, nfunc, name); - if (!sym) + if (!sym || sym->from_module) sym = find_sym (conversion, nconv, name); - return sym; + return (!sym || sym->from_module) ? NULL : sym; } @@ -735,7 +851,9 @@ gfc_find_function (const char *name) gfc_intrinsic_sym * gfc_find_subroutine (const char *name) { - return find_sym (subroutines, nsub, name); + gfc_intrinsic_sym *sym; + sym = find_sym (subroutines, nsub, name); + return (!sym || sym->from_module) ? NULL : sym; } @@ -748,7 +866,7 @@ gfc_generic_intrinsic (const char *name) gfc_intrinsic_sym *sym; sym = gfc_find_function (name); - return (sym == NULL) ? 0 : sym->generic; + return (!sym || sym->from_module) ? 0 : sym->generic; } @@ -761,7 +879,7 @@ gfc_specific_intrinsic (const char *name) gfc_intrinsic_sym *sym; sym = gfc_find_function (name); - return (sym == NULL) ? 0 : sym->specific; + return (!sym || sym->from_module) ? 0 : sym->specific; } @@ -783,15 +901,48 @@ gfc_intrinsic_actual_ok (const char *name, const bool subroutine_flag) } -/* Given a string, figure out if it is the name of an intrinsic - subroutine or function. There are no generic intrinsic - subroutines, they are all specific. */ +/* Given a symbol, find out if it is (and is to be treated) an intrinsic. If + it's 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. */ -int -gfc_intrinsic_name (const char *name, int subroutine_flag) +bool +gfc_is_intrinsic (gfc_symbol* sym, int subroutine_flag, locus loc) { - return subroutine_flag ? gfc_find_subroutine (name) != NULL - : gfc_find_function (name) != NULL; + gfc_intrinsic_sym* isym; + const char* symstd; + + /* If INTRINSIC/EXTERNAL state is already known, return. */ + if (sym->attr.intrinsic) + return true; + if (sym->attr.external) + 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) == FAILURE) + { + if (sym->attr.proc == PROC_UNKNOWN + && gfc_option.warn_intrinsics_std) + gfc_warning_now ("The intrinsic '%s' at %L is not included in the" + " selected standard but %s and '%s' 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; } @@ -829,8 +980,6 @@ make_generic (const char *name, gfc_isym_id id, int standard ATTRIBUTE_UNUSED) while (g->name != NULL) { - gcc_assert (g->id == id); - g->next = g + 1; g->specific = 1; g++; @@ -883,6 +1032,39 @@ make_noreturn (void) } +/* Mark current intrinsic as module intrinsic. */ +static void +make_from_module (void) +{ + if (sizing == SZ_NOTHING) + next_sym[-1].from_module = 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 @@ -902,7 +1084,9 @@ add_functions (void) *x = "x", *sh = "shift", *stg = "string", *ssg = "substring", *y = "y", *sz = "size", *sta = "string_a", *stb = "string_b", *z = "z", *ln = "len", *ut = "unit", *han = "handler", - *num = "number", *tm = "time", *nm = "name", *md = "mode"; + *num = "number", *tm = "time", *nm = "name", *md = "mode", + *vl = "values", *p1 = "path1", *p2 = "path2", *com = "command", + *ca = "coarray", *sub = "sub"; int di, dr, dd, dl, dc, dz, ii; @@ -923,7 +1107,7 @@ add_functions (void) a, BT_INTEGER, di, REQUIRED); add_sym_1 ("dabs", GFC_ISYM_ABS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77, - NULL, gfc_simplify_abs, gfc_resolve_abs, + 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, @@ -940,8 +1124,8 @@ add_functions (void) /* 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, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_access_func, NULL, gfc_resolve_access, + 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); @@ -954,34 +1138,34 @@ add_functions (void) 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_r, gfc_simplify_acos, gfc_resolve_acos, + 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, - NULL, gfc_simplify_acos, gfc_resolve_acos, + 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_GNU, - gfc_check_fn_r, gfc_simplify_acosh, gfc_resolve_acosh, - x, BT_REAL, dr, REQUIRED); + 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, - NULL, gfc_simplify_acosh, gfc_resolve_acosh, + gfc_check_fn_d, gfc_simplify_acosh, gfc_resolve_acosh, x, BT_REAL, dd, REQUIRED); - make_generic ("acosh", GFC_ISYM_ACOSH, GFC_STD_GNU); + 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, NULL, - stg, BT_CHARACTER, dc, REQUIRED); + 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, NULL, - stg, BT_CHARACTER, dc, REQUIRED); + 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); @@ -1009,7 +1193,7 @@ add_functions (void) 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, NULL, gfc_resolve_all, + 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); @@ -1031,30 +1215,30 @@ add_functions (void) 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, NULL, gfc_resolve_any, + 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_r, gfc_simplify_asin, gfc_resolve_asin, + 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, - NULL, gfc_simplify_asin, gfc_resolve_asin, + 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_GNU, - gfc_check_fn_r, gfc_simplify_asinh, gfc_resolve_asinh, - x, BT_REAL, dr, REQUIRED); + 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, - NULL, gfc_simplify_asinh, gfc_resolve_asinh, + gfc_check_fn_d, gfc_simplify_asinh, gfc_resolve_asinh, x, BT_REAL, dd, REQUIRED); - make_generic ("asinh", GFC_ISYM_ASINH, GFC_STD_GNU); + 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, @@ -1063,95 +1247,138 @@ add_functions (void) 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_r, gfc_simplify_atan, gfc_resolve_atan, + 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, - NULL, gfc_simplify_atan, gfc_resolve_atan, + 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_GNU, - gfc_check_fn_r, gfc_simplify_atanh, gfc_resolve_atanh, - x, BT_REAL, dr, REQUIRED); + 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, - NULL, gfc_simplify_atanh, gfc_resolve_atanh, + gfc_check_fn_d, gfc_simplify_atanh, gfc_resolve_atanh, x, BT_REAL, dd, REQUIRED); - make_generic ("atanh", GFC_ISYM_ATANH, GFC_STD_GNU); + 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, - NULL, gfc_simplify_atan2, gfc_resolve_atan2, + 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, NULL, gfc_resolve_g77_math1, + 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_r, NULL, gfc_resolve_g77_math1, + gfc_check_fn_d, gfc_simplify_bessel_j0, gfc_resolve_g77_math1, x, BT_REAL, dd, REQUIRED); - make_generic ("besj0", GFC_ISYM_J0, GFC_STD_GNU); + 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, NULL, gfc_resolve_g77_math1, + 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_r, NULL, gfc_resolve_g77_math1, + gfc_check_fn_d, gfc_simplify_bessel_j1, gfc_resolve_g77_math1, x, BT_REAL, dd, REQUIRED); - make_generic ("besj1", GFC_ISYM_J1, GFC_STD_GNU); + 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, NULL, gfc_resolve_besn, + 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, NULL, gfc_resolve_besn, + gfc_check_besn, gfc_simplify_bessel_jn, gfc_resolve_besn, n, BT_INTEGER, di, REQUIRED, x, BT_REAL, dd, REQUIRED); - make_generic ("besjn", GFC_ISYM_JN, GFC_STD_GNU); + 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, NULL, gfc_resolve_g77_math1, + 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_r, NULL, gfc_resolve_g77_math1, + gfc_check_fn_d, gfc_simplify_bessel_y0, gfc_resolve_g77_math1, x, BT_REAL, dd, REQUIRED); - make_generic ("besy0", GFC_ISYM_Y0, GFC_STD_GNU); + 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, NULL, gfc_resolve_g77_math1, + 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_r, NULL, gfc_resolve_g77_math1, + gfc_check_fn_d, gfc_simplify_bessel_y1, gfc_resolve_g77_math1, x, BT_REAL, dd, REQUIRED); - make_generic ("besy1", GFC_ISYM_Y1, GFC_STD_GNU); + 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, NULL, gfc_resolve_besn, + 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, NULL, gfc_resolve_besn, + gfc_check_besn, gfc_simplify_bessel_yn, gfc_resolve_besn, n, BT_INTEGER, di, REQUIRED, x, BT_REAL, dd, REQUIRED); - make_generic ("besyn", GFC_ISYM_YN, GFC_STD_GNU); + 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, @@ -1159,8 +1386,22 @@ add_functions (void) 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_btest, gfc_simplify_btest, gfc_resolve_btest, + gfc_check_bitfcn, gfc_simplify_btest, gfc_resolve_btest, i, BT_INTEGER, di, REQUIRED, pos, BT_INTEGER, di, REQUIRED); make_generic ("btest", GFC_ISYM_BTEST, GFC_STD_F95); @@ -1177,14 +1418,14 @@ add_functions (void) make_generic ("char", GFC_ISYM_CHAR, GFC_STD_F77); - add_sym_1 ("chdir", GFC_ISYM_CHDIR, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, + 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, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_chmod, NULL, gfc_resolve_chmod, + 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); @@ -1232,7 +1473,7 @@ add_functions (void) 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_rc, gfc_simplify_cos, gfc_resolve_cos, + 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, @@ -1248,18 +1489,18 @@ add_functions (void) 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_r, gfc_simplify_cosh, gfc_resolve_cosh, + 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, - NULL, gfc_simplify_cosh, gfc_resolve_cosh, + 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, NULL, gfc_resolve_count, + gfc_check_count, gfc_simplify_count, gfc_resolve_count, msk, BT_LOGICAL, dl, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL, kind, BT_INTEGER, di, OPTIONAL); @@ -1272,9 +1513,9 @@ add_functions (void) make_generic ("cshift", GFC_ISYM_CSHIFT, GFC_STD_F95); - add_sym_1 ("ctime", GFC_ISYM_CTIME, NO_CLASS, ACTUAL_NO, BT_CHARACTER, 0, GFC_STD_GNU, - gfc_check_ctime, NULL, gfc_resolve_ctime, - tm, BT_INTEGER, di, REQUIRED); + 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); @@ -1282,8 +1523,6 @@ add_functions (void) gfc_check_dble, gfc_simplify_dble, gfc_resolve_dble, a, BT_REAL, dr, REQUIRED); - make_alias ("dfloat", GFC_STD_GNU); - 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, @@ -1294,40 +1533,58 @@ add_functions (void) 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_UNKNOWN, dr, REQUIRED); + 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, - NULL, gfc_simplify_dim, gfc_resolve_dim, + 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, NULL, gfc_resolve_dot_product, + 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, - NULL, gfc_simplify_dprod, gfc_resolve_dprod, + 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, NULL, NULL, + 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, NULL, gfc_resolve_eoshift, - ar, BT_REAL, dr, 0, sh, BT_INTEGER, ii, REQUIRED, - bd, BT_REAL, dr, 1, dm, BT_INTEGER, ii, OPTIONAL); + 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); @@ -1338,32 +1595,43 @@ add_functions (void) 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_GNU, - gfc_check_fn_r, NULL, gfc_resolve_g77_math1, - x, BT_REAL, dr, REQUIRED); + 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_r, NULL, gfc_resolve_g77_math1, - x, BT_REAL, dd, 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_GNU); + 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_GNU, - gfc_check_fn_r, NULL, gfc_resolve_g77_math1, - x, BT_REAL, dr, REQUIRED); + 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_r, NULL, gfc_resolve_g77_math1, - x, BT_REAL, dd, 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); - make_generic ("erfc", GFC_ISYM_ERFC, GFC_STD_GNU); + 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 ("etime", GFC_ISYM_ETIME, NO_CLASS, ACTUAL_NO, BT_REAL, 4, GFC_STD_GNU, - gfc_check_etime, NULL, NULL, + 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_alias ("dtime", GFC_STD_GNU); + 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); @@ -1372,7 +1640,7 @@ add_functions (void) x, BT_REAL, dr, REQUIRED); add_sym_1 ("dexp", GFC_ISYM_EXP, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77, - NULL, gfc_simplify_exp, gfc_resolve_exp, + 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, @@ -1393,8 +1661,15 @@ add_functions (void) make_generic ("exponent", GFC_ISYM_EXPONENT, GFC_STD_F95); - add_sym_0 ("fdate", GFC_ISYM_FDATE, NO_CLASS, ACTUAL_NO, BT_CHARACTER, dc, GFC_STD_GNU, - NULL, NULL, gfc_resolve_fdate); + 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_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); @@ -1405,8 +1680,8 @@ add_functions (void) make_generic ("floor", GFC_ISYM_FLOOR, GFC_STD_F95); /* G77 compatible fnum */ - add_sym_1 ("fnum", GFC_ISYM_FNUM, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_fnum, NULL, gfc_resolve_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); @@ -1417,77 +1692,82 @@ add_functions (void) make_generic ("fraction", GFC_ISYM_FRACTION, GFC_STD_F95); - add_sym_2 ("fstat", GFC_ISYM_FSTAT, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_fstat, NULL, gfc_resolve_fstat, - a, BT_INTEGER, di, REQUIRED, b, BT_INTEGER, di, REQUIRED); + 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, NO_CLASS, ACTUAL_NO, BT_INTEGER, ii, GFC_STD_GNU, - gfc_check_ftell, NULL, gfc_resolve_ftell, + 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 ("fgetc", GFC_ISYM_FGETC, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_fgetputc, NULL, gfc_resolve_fgetc, - ut, BT_INTEGER, di, REQUIRED, c, BT_CHARACTER, dc, REQUIRED); + 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 ("fget", GFC_ISYM_FGET, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_fgetput, NULL, gfc_resolve_fget, - c, BT_CHARACTER, dc, REQUIRED); + 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, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_fgetputc, NULL, gfc_resolve_fputc, + 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, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_fgetput, NULL, gfc_resolve_fput, + 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_GAMMA, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU, - gfc_check_fn_r, gfc_simplify_gamma, gfc_resolve_gamma, - x, BT_REAL, dr, REQUIRED); + 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_GAMMA, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU, - gfc_check_fn_r, gfc_simplify_gamma, gfc_resolve_gamma, + 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_GAMMA, GFC_STD_GNU); + make_generic ("gamma", GFC_ISYM_TGAMMA, GFC_STD_F2008); /* Unix IDs (g77 compatibility) */ - add_sym_1 ("getcwd", GFC_ISYM_GETCWD, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - NULL, NULL, gfc_resolve_getcwd, + 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, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - NULL, NULL, gfc_resolve_getgid); + 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, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - NULL, NULL, gfc_resolve_getpid); + 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_0 ("getuid", GFC_ISYM_GETUID, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - NULL, NULL, gfc_resolve_getuid); + 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 ("hostnm", GFC_ISYM_HOSTNM, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_hostnm, NULL, gfc_resolve_hostnm, - a, BT_CHARACTER, dc, REQUIRED); + 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); @@ -1497,6 +1777,13 @@ add_functions (void) 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, @@ -1510,19 +1797,33 @@ add_functions (void) make_generic ("iand", GFC_ISYM_IAND, GFC_STD_F95); - add_sym_2 ("and", GFC_ISYM_AND, NO_CLASS, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_GNU, - gfc_check_and, gfc_simplify_and, gfc_resolve_and, + 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_0 ("iargc", GFC_ISYM_IARGC, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - NULL, NULL, NULL); + 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_ibclr, gfc_simplify_ibclr, gfc_resolve_ibclr, + gfc_check_bitfcn, gfc_simplify_ibclr, gfc_resolve_ibclr, i, BT_INTEGER, di, REQUIRED, pos, BT_INTEGER, di, REQUIRED); make_generic ("ibclr", GFC_ISYM_IBCLR, GFC_STD_F95); @@ -1535,7 +1836,7 @@ add_functions (void) 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_ibset, gfc_simplify_ibset, gfc_resolve_ibset, + gfc_check_bitfcn, gfc_simplify_ibset, gfc_resolve_ibset, i, BT_INTEGER, di, REQUIRED, pos, BT_INTEGER, di, REQUIRED); make_generic ("ibset", GFC_ISYM_IBSET, GFC_STD_F95); @@ -1553,17 +1854,21 @@ add_functions (void) make_generic ("ieor", GFC_ISYM_IEOR, GFC_STD_F95); - add_sym_2 ("xor", GFC_ISYM_XOR, NO_CLASS, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_GNU, - gfc_check_and, gfc_simplify_xor, gfc_resolve_xor, + 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, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - NULL, NULL, gfc_resolve_ierrno); + 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); + /* 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_4 ("index", GFC_ISYM_INDEX, CLASS_ELEMENTAL, ACTUAL_YES, @@ -1614,51 +1919,63 @@ add_functions (void) make_generic ("ior", GFC_ISYM_IOR, GFC_STD_F95); - add_sym_2 ("or", GFC_ISYM_OR, NO_CLASS, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_GNU, - gfc_check_and, gfc_simplify_or, gfc_resolve_or, + 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, NO_CLASS, ACTUAL_NO, BT_INTEGER, 4, GFC_STD_GNU, - gfc_check_irand, NULL, NULL, + 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, NO_CLASS, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_GNU, - gfc_check_isatty, NULL, gfc_resolve_isatty, + 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_iostat_end", GFC_ISYM_IS_IOSTAT_END, CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F2003, - gfc_check_i, NULL, NULL, i, BT_INTEGER, 0, REQUIRED); + 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, NULL, NULL, i, BT_INTEGER, 0, REQUIRED); + 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, NULL, NULL, + 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, NULL, gfc_resolve_rshift, + 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, NULL, gfc_resolve_lshift, + 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); @@ -1676,8 +1993,8 @@ add_functions (void) make_generic ("ishftc", GFC_ISYM_ISHFTC, GFC_STD_F95); - add_sym_2 ("kill", GFC_ISYM_KILL, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_kill, NULL, gfc_resolve_kill, + add_sym_2 ("kill", GFC_ISYM_KILL, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, + di, GFC_STD_GNU, gfc_check_kill, NULL, gfc_resolve_kill, a, BT_INTEGER, di, REQUIRED, b, BT_INTEGER, di, REQUIRED); make_generic ("kill", GFC_ISYM_KILL, GFC_STD_GNU); @@ -1696,6 +2013,21 @@ add_functions (void) 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, @@ -1712,48 +2044,51 @@ add_functions (void) 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, + 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_r, gfc_simplify_lgamma, gfc_resolve_lgamma, + gfc_check_fn_d, gfc_simplify_lgamma, gfc_resolve_lgamma, x, BT_REAL, dr, REQUIRED); - make_generic ("lgamma", GFC_ISYM_LGAMMA, GFC_STD_GNU); + 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, - NULL, gfc_simplify_lge, NULL, + 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, - NULL, gfc_simplify_lgt, NULL, + 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, - NULL, gfc_simplify_lle, NULL, + 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, - NULL, gfc_simplify_llt, NULL, + 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, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_link, NULL, gfc_resolve_link, - a, BT_CHARACTER, dc, REQUIRED, b, BT_CHARACTER, dc, REQUIRED); + 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); @@ -1766,7 +2101,7 @@ add_functions (void) x, BT_REAL, dr, REQUIRED); add_sym_1 ("dlog", GFC_ISYM_LOG, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77, - NULL, gfc_simplify_log, gfc_resolve_log, + 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, @@ -1790,7 +2125,7 @@ add_functions (void) x, BT_REAL, dr, REQUIRED); add_sym_1 ("dlog10", GFC_ISYM_LOG10, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77, - NULL, gfc_simplify_log10, gfc_resolve_log10, + gfc_check_fn_d, gfc_simplify_log10, gfc_resolve_log10, x, BT_REAL, dd, REQUIRED); make_generic ("log10", GFC_ISYM_LOG10, GFC_STD_F77); @@ -1801,20 +2136,38 @@ add_functions (void) make_generic ("logical", GFC_ISYM_LOGICAL, GFC_STD_F95); - add_sym_2 ("lstat", GFC_ISYM_LSTAT, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_stat, NULL, gfc_resolve_lstat, - a, BT_CHARACTER, dc, REQUIRED, b, BT_INTEGER, di, REQUIRED); + 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, NO_CLASS, ACTUAL_NO, BT_INTEGER, ii, GFC_STD_GNU, - gfc_check_malloc, NULL, gfc_resolve_malloc, a, BT_INTEGER, di, - REQUIRED); + add_sym_1 ("malloc", GFC_ISYM_MALLOC, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, ii, + GFC_STD_GNU, gfc_check_malloc, NULL, gfc_resolve_malloc, + 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, NULL, gfc_resolve_matmul, + gfc_check_matmul, gfc_simplify_matmul, gfc_resolve_matmul, ma, BT_REAL, dr, REQUIRED, mb, BT_REAL, dr, REQUIRED); make_generic ("matmul", GFC_ISYM_MATMUL, GFC_STD_F95); @@ -1862,29 +2215,39 @@ add_functions (void) make_generic ("maxloc", GFC_ISYM_MAXLOC, GFC_STD_F95); add_sym_3red ("maxval", GFC_ISYM_MAXVAL, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95, - gfc_check_minval_maxval, NULL, gfc_resolve_maxval, + gfc_check_minval_maxval, gfc_simplify_maxval, gfc_resolve_maxval, ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL, msk, BT_LOGICAL, dl, OPTIONAL); make_generic ("maxval", GFC_ISYM_MAXVAL, GFC_STD_F95); - add_sym_0 ("mclock", GFC_ISYM_MCLOCK, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - NULL, NULL, gfc_resolve_mclock); + add_sym_0 ("mclock", GFC_ISYM_MCLOCK, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, di, + GFC_STD_GNU, NULL, NULL, gfc_resolve_mclock); make_generic ("mclock", GFC_ISYM_MCLOCK, GFC_STD_GNU); - add_sym_0 ("mclock8", GFC_ISYM_MCLOCK8, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - NULL, NULL, gfc_resolve_mclock8); + add_sym_0 ("mclock8", GFC_ISYM_MCLOCK8, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, + di, GFC_STD_GNU, NULL, NULL, gfc_resolve_mclock8); make_generic ("mclock8", GFC_ISYM_MCLOCK8, GFC_STD_GNU); add_sym_3 ("merge", GFC_ISYM_MERGE, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95, - gfc_check_merge, NULL, gfc_resolve_merge, + gfc_check_merge, gfc_simplify_merge, gfc_resolve_merge, ts, BT_REAL, dr, REQUIRED, fs, BT_REAL, dr, REQUIRED, msk, BT_LOGICAL, dl, REQUIRED); make_generic ("merge", GFC_ISYM_MERGE, GFC_STD_F95); + add_sym_3 ("merge_bits", GFC_ISYM_MERGE_BITS, CLASS_ELEMENTAL, ACTUAL_NO, + BT_INTEGER, di, GFC_STD_F2008, + gfc_check_merge_bits, gfc_simplify_merge_bits, + gfc_resolve_merge_bits, + i, BT_INTEGER, di, REQUIRED, + j, BT_INTEGER, di, REQUIRED, + msk, BT_INTEGER, di, REQUIRED); + + make_generic ("merge_bits", GFC_ISYM_MERGE_BITS, GFC_STD_F2008); + /* Note: amin0 is equivalent to real(min), min1 is equivalent to int(min). */ @@ -1928,7 +2291,7 @@ add_functions (void) 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, - gfc_check_minval_maxval, NULL, gfc_resolve_minval, + gfc_check_minval_maxval, gfc_simplify_minval, gfc_resolve_minval, ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL, msk, BT_LOGICAL, dl, OPTIONAL); @@ -1943,7 +2306,7 @@ add_functions (void) a, BT_REAL, dr, REQUIRED, p, BT_REAL, dr, REQUIRED); add_sym_2 ("dmod", GFC_ISYM_MOD, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77, - NULL, gfc_simplify_mod, gfc_resolve_mod, + gfc_check_x_yd, gfc_simplify_mod, gfc_resolve_mod, a, BT_REAL, dd, REQUIRED, p, BT_REAL, dd, REQUIRED); make_generic ("mod", GFC_ISYM_MOD, GFC_STD_F77); @@ -1982,33 +2345,66 @@ add_functions (void) make_generic ("not", GFC_ISYM_NOT, GFC_STD_F95); + add_sym_2 ("norm2", GFC_ISYM_NORM2, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, + GFC_STD_F2008, gfc_check_norm2, gfc_simplify_norm2, gfc_resolve_norm2, + x, BT_REAL, dr, REQUIRED, + dm, BT_INTEGER, ii, OPTIONAL); + + make_generic ("norm2", GFC_ISYM_NORM2, GFC_STD_F2008); + add_sym_1 ("null", GFC_ISYM_NULL, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95, gfc_check_null, gfc_simplify_null, NULL, mo, BT_INTEGER, di, OPTIONAL); make_generic ("null", GFC_ISYM_NULL, GFC_STD_F95); + add_sym_0 ("num_images", GFC_ISYM_NUM_IMAGES, CLASS_INQUIRY, ACTUAL_NO, + BT_INTEGER, di, GFC_STD_F2008, + NULL, gfc_simplify_num_images, NULL); + add_sym_3 ("pack", GFC_ISYM_PACK, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95, - gfc_check_pack, NULL, gfc_resolve_pack, + gfc_check_pack, gfc_simplify_pack, gfc_resolve_pack, ar, BT_REAL, dr, REQUIRED, msk, BT_LOGICAL, dl, REQUIRED, v, BT_REAL, dr, OPTIONAL); make_generic ("pack", GFC_ISYM_PACK, GFC_STD_F95); + + add_sym_2 ("parity", GFC_ISYM_PARITY, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_LOGICAL, dl, + GFC_STD_F2008, gfc_check_parity, gfc_simplify_parity, gfc_resolve_parity, + msk, BT_LOGICAL, dl, REQUIRED, + dm, BT_INTEGER, ii, OPTIONAL); + + make_generic ("parity", GFC_ISYM_PARITY, GFC_STD_F2008); + + add_sym_1 ("popcnt", GFC_ISYM_POPCNT, CLASS_ELEMENTAL, ACTUAL_NO, + BT_INTEGER, di, GFC_STD_F2008, + gfc_check_i, gfc_simplify_popcnt, NULL, + i, BT_INTEGER, di, REQUIRED); + + make_generic ("popcnt", GFC_ISYM_POPCNT, GFC_STD_F2008); + + add_sym_1 ("poppar", GFC_ISYM_POPPAR, CLASS_ELEMENTAL, ACTUAL_NO, + BT_INTEGER, di, GFC_STD_F2008, + gfc_check_i, gfc_simplify_poppar, NULL, + i, BT_INTEGER, di, REQUIRED); + + make_generic ("poppar", GFC_ISYM_POPPAR, GFC_STD_F2008); + add_sym_1 ("precision", GFC_ISYM_PRECISION, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95, gfc_check_precision, gfc_simplify_precision, NULL, x, BT_UNKNOWN, 0, REQUIRED); make_generic ("precision", GFC_ISYM_PRECISION, GFC_STD_F95); - add_sym_1 ("present", GFC_ISYM_PRESENT, CLASS_INQUIRY, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F95, - gfc_check_present, NULL, NULL, - a, BT_REAL, dr, REQUIRED); + add_sym_1_intent ("present", GFC_ISYM_PRESENT, CLASS_INQUIRY, ACTUAL_NO, + BT_LOGICAL, dl, GFC_STD_F95, gfc_check_present, NULL, NULL, + a, BT_REAL, dr, REQUIRED, INTENT_UNKNOWN); make_generic ("present", GFC_ISYM_PRESENT, GFC_STD_F95); add_sym_3red ("product", GFC_ISYM_PRODUCT, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95, - gfc_check_product_sum, NULL, gfc_resolve_product, + gfc_check_product_sum, gfc_simplify_product, gfc_resolve_product, ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL, msk, BT_LOGICAL, dl, OPTIONAL); @@ -2021,8 +2417,8 @@ add_functions (void) make_generic ("radix", GFC_ISYM_RADIX, GFC_STD_F95); /* The following function is for G77 compatibility. */ - add_sym_1 ("rand", GFC_ISYM_RAND, NO_CLASS, ACTUAL_NO, BT_REAL, 4, GFC_STD_GNU, - gfc_check_rand, NULL, NULL, + add_sym_1 ("rand", GFC_ISYM_RAND, CLASS_IMPURE, ACTUAL_NO, BT_REAL, + 4, GFC_STD_GNU, gfc_check_rand, NULL, NULL, i, BT_INTEGER, 4, OPTIONAL); /* Compatibility with HP FORTRAN 77/iX Reference. Note, rand() and ran() @@ -2037,6 +2433,11 @@ add_functions (void) make_generic ("range", GFC_ISYM_RANGE, GFC_STD_F95); + add_sym_1 ("rank", GFC_ISYM_RANK, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, + GFC_STD_F2008_TS, gfc_check_rank, gfc_simplify_rank, NULL, + a, BT_REAL, dr, REQUIRED); + make_generic ("rank", GFC_ISYM_RANK, GFC_STD_F2008_TS); + add_sym_2 ("real", GFC_ISYM_REAL, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F77, gfc_check_real, gfc_simplify_real, gfc_resolve_real, a, BT_UNKNOWN, dr, REQUIRED, kind, BT_INTEGER, di, OPTIONAL); @@ -2047,18 +2448,22 @@ add_functions (void) a, BT_UNKNOWN, dr, REQUIRED); add_sym_1 ("float", GFC_ISYM_REAL, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F77, - gfc_check_i, gfc_simplify_float, NULL, + gfc_check_float, gfc_simplify_float, NULL, a, BT_INTEGER, di, REQUIRED); + add_sym_1 ("dfloat", GFC_ISYM_REAL, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_GNU, + gfc_check_float, gfc_simplify_dble, gfc_resolve_dble, + a, BT_REAL, dr, REQUIRED); + add_sym_1 ("sngl", GFC_ISYM_REAL, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F77, - NULL, gfc_simplify_sngl, NULL, + gfc_check_sngl, gfc_simplify_sngl, NULL, a, BT_REAL, dd, REQUIRED); make_generic ("real", GFC_ISYM_REAL, GFC_STD_F77); - add_sym_2 ("rename", GFC_ISYM_RENAME, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_rename, NULL, gfc_resolve_rename, - a, BT_CHARACTER, dc, REQUIRED, b, BT_CHARACTER, dc, REQUIRED); + add_sym_2 ("rename", GFC_ISYM_RENAME, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, di, + GFC_STD_GNU, gfc_check_rename, NULL, gfc_resolve_rename, + p1, BT_CHARACTER, dc, REQUIRED, p2, BT_CHARACTER, dc, REQUIRED); make_generic ("rename", GFC_ISYM_RENAME, GFC_STD_GNU); @@ -2081,6 +2486,12 @@ add_functions (void) make_generic ("rrspacing", GFC_ISYM_RRSPACING, GFC_STD_F95); + add_sym_2 ("same_type_as", GFC_ISYM_SAME_TYPE_AS, CLASS_INQUIRY, ACTUAL_NO, + BT_LOGICAL, dl, GFC_STD_F2003, + gfc_check_same_type_as, gfc_simplify_same_type_as, NULL, + a, BT_UNKNOWN, 0, REQUIRED, + b, BT_UNKNOWN, 0, REQUIRED); + add_sym_2 ("scale", GFC_ISYM_SCALE, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95, gfc_check_scale, gfc_simplify_scale, gfc_resolve_scale, x, BT_REAL, dr, REQUIRED, i, BT_INTEGER, di, REQUIRED); @@ -2096,28 +2507,36 @@ add_functions (void) make_generic ("scan", GFC_ISYM_SCAN, GFC_STD_F95); /* Added for G77 compatibility garbage. */ - add_sym_0 ("second", GFC_ISYM_SECOND, NO_CLASS, ACTUAL_NO, BT_REAL, 4, GFC_STD_GNU, - NULL, NULL, NULL); + add_sym_0 ("second", GFC_ISYM_SECOND, CLASS_IMPURE, ACTUAL_NO, BT_REAL, + 4, GFC_STD_GNU, NULL, NULL, NULL); make_generic ("second", GFC_ISYM_SECOND, GFC_STD_GNU); /* Added for G77 compatibility. */ - add_sym_1 ("secnds", GFC_ISYM_SECNDS, NO_CLASS, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU, - gfc_check_secnds, NULL, gfc_resolve_secnds, + add_sym_1 ("secnds", GFC_ISYM_SECNDS, CLASS_IMPURE, ACTUAL_NO, BT_REAL, + dr, GFC_STD_GNU, gfc_check_secnds, NULL, gfc_resolve_secnds, x, BT_REAL, dr, REQUIRED); make_generic ("secnds", GFC_ISYM_SECNDS, GFC_STD_GNU); + add_sym_1 ("selected_char_kind", GFC_ISYM_SC_KIND, CLASS_TRANSFORMATIONAL, + ACTUAL_NO, BT_INTEGER, di, GFC_STD_F2003, + gfc_check_selected_char_kind, gfc_simplify_selected_char_kind, + NULL, nm, BT_CHARACTER, dc, REQUIRED); + + make_generic ("selected_char_kind", GFC_ISYM_SC_KIND, GFC_STD_F2003); + add_sym_1 ("selected_int_kind", GFC_ISYM_SI_KIND, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95, gfc_check_selected_int_kind, gfc_simplify_selected_int_kind, NULL, r, BT_INTEGER, di, REQUIRED); make_generic ("selected_int_kind", GFC_ISYM_SI_KIND, GFC_STD_F95); - add_sym_2 ("selected_real_kind", GFC_ISYM_SR_KIND, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, + add_sym_3 ("selected_real_kind", GFC_ISYM_SR_KIND, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95, gfc_check_selected_real_kind, gfc_simplify_selected_real_kind, NULL, - p, BT_INTEGER, di, OPTIONAL, r, BT_INTEGER, di, OPTIONAL); + p, BT_INTEGER, di, OPTIONAL, r, BT_INTEGER, di, OPTIONAL, + "radix", BT_INTEGER, di, OPTIONAL); make_generic ("selected_real_kind", GFC_ISYM_SR_KIND, GFC_STD_F95); @@ -2128,12 +2547,37 @@ add_functions (void) make_generic ("set_exponent", GFC_ISYM_SET_EXPONENT, GFC_STD_F95); - add_sym_1 ("shape", GFC_ISYM_SHAPE, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95, + add_sym_2 ("shape", GFC_ISYM_SHAPE, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95, gfc_check_shape, gfc_simplify_shape, gfc_resolve_shape, - src, BT_REAL, dr, REQUIRED); + src, BT_REAL, dr, REQUIRED, + kind, BT_INTEGER, di, OPTIONAL); make_generic ("shape", GFC_ISYM_SHAPE, GFC_STD_F95); + add_sym_2 ("shifta", GFC_ISYM_SHIFTA, CLASS_ELEMENTAL, ACTUAL_NO, + BT_INTEGER, di, GFC_STD_F2008, + gfc_check_shift, gfc_simplify_shifta, gfc_resolve_shift, + i, BT_INTEGER, di, REQUIRED, + sh, BT_INTEGER, di, REQUIRED); + + make_generic ("shifta", GFC_ISYM_SHIFTA, GFC_STD_F2008); + + add_sym_2 ("shiftl", GFC_ISYM_SHIFTL, CLASS_ELEMENTAL, ACTUAL_NO, + BT_INTEGER, di, GFC_STD_F2008, + gfc_check_shift, gfc_simplify_shiftl, gfc_resolve_shift, + i, BT_INTEGER, di, REQUIRED, + sh, BT_INTEGER, di, REQUIRED); + + make_generic ("shiftl", GFC_ISYM_SHIFTL, GFC_STD_F2008); + + add_sym_2 ("shiftr", GFC_ISYM_SHIFTR, CLASS_ELEMENTAL, ACTUAL_NO, + BT_INTEGER, di, GFC_STD_F2008, + gfc_check_shift, gfc_simplify_shiftr, gfc_resolve_shift, + i, BT_INTEGER, di, REQUIRED, + sh, BT_INTEGER, di, REQUIRED); + + make_generic ("shiftr", GFC_ISYM_SHIFTR, GFC_STD_F2008); + add_sym_2 ("sign", GFC_ISYM_SIGN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77, gfc_check_sign, gfc_simplify_sign, gfc_resolve_sign, a, BT_REAL, dr, REQUIRED, b, BT_REAL, dr, REQUIRED); @@ -2143,14 +2587,14 @@ add_functions (void) a, BT_INTEGER, di, REQUIRED, b, BT_INTEGER, di, REQUIRED); add_sym_2 ("dsign", GFC_ISYM_SIGN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77, - NULL, gfc_simplify_sign, gfc_resolve_sign, + gfc_check_x_yd, gfc_simplify_sign, gfc_resolve_sign, a, BT_REAL, dd, REQUIRED, b, BT_REAL, dd, REQUIRED); make_generic ("sign", GFC_ISYM_SIGN, GFC_STD_F77); - add_sym_2 ("signal", GFC_ISYM_SIGNAL, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_signal, NULL, gfc_resolve_signal, - num, BT_INTEGER, di, REQUIRED, han, BT_UNKNOWN, 0, REQUIRED); + add_sym_2 ("signal", GFC_ISYM_SIGNAL, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, + di, GFC_STD_GNU, gfc_check_signal, NULL, gfc_resolve_signal, + num, BT_INTEGER, di, REQUIRED, han, BT_VOID, 0, REQUIRED); make_generic ("signal", GFC_ISYM_SIGNAL, GFC_STD_GNU); @@ -2159,7 +2603,7 @@ add_functions (void) x, BT_REAL, dr, REQUIRED); add_sym_1 ("dsin", GFC_ISYM_SIN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77, - NULL, gfc_simplify_sin, gfc_resolve_sin, + gfc_check_fn_d, gfc_simplify_sin, gfc_resolve_sin, x, BT_REAL, dd, REQUIRED); add_sym_1 ("csin", GFC_ISYM_SIN, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dz, GFC_STD_F77, @@ -2175,11 +2619,11 @@ add_functions (void) make_generic ("sin", GFC_ISYM_SIN, GFC_STD_F77); add_sym_1 ("sinh", GFC_ISYM_SINH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77, - gfc_check_fn_r, gfc_simplify_sinh, gfc_resolve_sinh, + gfc_check_fn_rc2008, gfc_simplify_sinh, gfc_resolve_sinh, x, BT_REAL, dr, REQUIRED); add_sym_1 ("dsinh", GFC_ISYM_SINH,CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77, - NULL, gfc_simplify_sinh, gfc_resolve_sinh, + gfc_check_fn_d, gfc_simplify_sinh, gfc_resolve_sinh, x, BT_REAL, dd, REQUIRED); make_generic ("sinh", GFC_ISYM_SINH, GFC_STD_F77); @@ -2192,12 +2636,29 @@ add_functions (void) make_generic ("size", GFC_ISYM_SIZE, GFC_STD_F95); - add_sym_1 ("sizeof", GFC_ISYM_SIZEOF, NO_CLASS, ACTUAL_NO, BT_INTEGER, ii, + add_sym_1 ("sizeof", GFC_ISYM_SIZEOF, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, ii, GFC_STD_GNU, gfc_check_sizeof, NULL, NULL, - i, BT_UNKNOWN, 0, REQUIRED); + x, BT_UNKNOWN, 0, REQUIRED); make_generic ("sizeof", GFC_ISYM_SIZEOF, GFC_STD_GNU); + /* C_SIZEOF is part of ISO_C_BINDING. */ + add_sym_1 ("c_sizeof", GFC_ISYM_C_SIZEOF, CLASS_INQUIRY, ACTUAL_NO, + BT_INTEGER, ii, GFC_STD_F2008, gfc_check_c_sizeof, NULL, NULL, + x, BT_UNKNOWN, 0, REQUIRED); + make_from_module(); + + /* COMPILER_OPTIONS and COMPILER_VERSION are part of ISO_FORTRAN_ENV. */ + add_sym_0 ("compiler_options", GFC_ISYM_COMPILER_OPTIONS, CLASS_INQUIRY, + ACTUAL_NO, BT_CHARACTER, dc, GFC_STD_F2008, + NULL, gfc_simplify_compiler_options, NULL); + make_from_module(); + + add_sym_0 ("compiler_version", GFC_ISYM_COMPILER_VERSION, CLASS_INQUIRY, + ACTUAL_NO, BT_CHARACTER, dc, GFC_STD_F2008, + NULL, gfc_simplify_compiler_version, NULL); + make_from_module(); + add_sym_1 ("spacing", GFC_ISYM_SPACING, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95, gfc_check_x, gfc_simplify_spacing, gfc_resolve_spacing, x, BT_REAL, dr, REQUIRED); @@ -2205,7 +2666,7 @@ add_functions (void) make_generic ("spacing", GFC_ISYM_SPACING, GFC_STD_F95); add_sym_3 ("spread", GFC_ISYM_SPREAD, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95, - gfc_check_spread, NULL, gfc_resolve_spread, + gfc_check_spread, gfc_simplify_spread, gfc_resolve_spread, src, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, REQUIRED, ncopies, BT_INTEGER, di, REQUIRED); @@ -2216,7 +2677,7 @@ add_functions (void) x, BT_REAL, dr, REQUIRED); add_sym_1 ("dsqrt", GFC_ISYM_SQRT, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77, - NULL, gfc_simplify_sqrt, gfc_resolve_sqrt, + gfc_check_fn_d, gfc_simplify_sqrt, gfc_resolve_sqrt, x, BT_REAL, dd, REQUIRED); add_sym_1 ("csqrt", GFC_ISYM_SQRT, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dz, GFC_STD_F77, @@ -2231,58 +2692,70 @@ add_functions (void) make_generic ("sqrt", GFC_ISYM_SQRT, GFC_STD_F77); - add_sym_2 ("stat", GFC_ISYM_STAT, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_stat, NULL, gfc_resolve_stat, - a, BT_CHARACTER, dc, REQUIRED, b, BT_INTEGER, di, REQUIRED); + add_sym_2_intent ("stat", GFC_ISYM_STAT, CLASS_IMPURE, ACTUAL_NO, + BT_INTEGER, di, GFC_STD_GNU, + gfc_check_stat, NULL, gfc_resolve_stat, + nm, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + vl, BT_INTEGER, di, REQUIRED, INTENT_OUT); make_generic ("stat", GFC_ISYM_STAT, GFC_STD_GNU); + add_sym_2 ("storage_size", GFC_ISYM_STORAGE_SIZE, CLASS_INQUIRY, ACTUAL_NO, + BT_INTEGER, di, GFC_STD_F2008, + gfc_check_storage_size, NULL, gfc_resolve_storage_size, + a, BT_UNKNOWN, 0, REQUIRED, + kind, BT_INTEGER, di, OPTIONAL); + add_sym_3red ("sum", GFC_ISYM_SUM, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95, - gfc_check_product_sum, NULL, gfc_resolve_sum, + gfc_check_product_sum, gfc_simplify_sum, gfc_resolve_sum, ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL, msk, BT_LOGICAL, dl, OPTIONAL); make_generic ("sum", GFC_ISYM_SUM, GFC_STD_F95); - add_sym_2 ("symlnk", GFC_ISYM_SYMLNK, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_symlnk, NULL, gfc_resolve_symlnk, - a, BT_CHARACTER, dc, REQUIRED, b, BT_CHARACTER, dc, REQUIRED); + add_sym_2 ("symlnk", GFC_ISYM_SYMLNK, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, di, + GFC_STD_GNU, gfc_check_symlnk, NULL, gfc_resolve_symlnk, + p1, BT_CHARACTER, dc, REQUIRED, p2, BT_CHARACTER, dc, REQUIRED); make_generic ("symlnk", GFC_ISYM_SYMLNK, GFC_STD_GNU); - add_sym_1 ("system", GFC_ISYM_SYSTEM, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - NULL, NULL, NULL, - c, BT_CHARACTER, dc, REQUIRED); + add_sym_1 ("system", GFC_ISYM_SYSTEM, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, di, + GFC_STD_GNU, NULL, NULL, NULL, + com, BT_CHARACTER, dc, REQUIRED); make_generic ("system", GFC_ISYM_SYSTEM, GFC_STD_GNU); add_sym_1 ("tan", GFC_ISYM_TAN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77, - gfc_check_fn_r, gfc_simplify_tan, gfc_resolve_tan, + gfc_check_fn_rc2008, gfc_simplify_tan, gfc_resolve_tan, x, BT_REAL, dr, REQUIRED); add_sym_1 ("dtan", GFC_ISYM_TAN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77, - NULL, gfc_simplify_tan, gfc_resolve_tan, + gfc_check_fn_d, gfc_simplify_tan, gfc_resolve_tan, x, BT_REAL, dd, REQUIRED); make_generic ("tan", GFC_ISYM_TAN, GFC_STD_F77); add_sym_1 ("tanh", GFC_ISYM_TANH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77, - gfc_check_fn_r, gfc_simplify_tanh, gfc_resolve_tanh, + gfc_check_fn_rc2008, gfc_simplify_tanh, gfc_resolve_tanh, x, BT_REAL, dr, REQUIRED); add_sym_1 ("dtanh", GFC_ISYM_TANH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77, - NULL, gfc_simplify_tanh, gfc_resolve_tanh, + gfc_check_fn_d, gfc_simplify_tanh, gfc_resolve_tanh, x, BT_REAL, dd, REQUIRED); make_generic ("tanh", GFC_ISYM_TANH, GFC_STD_F77); - add_sym_0 ("time", GFC_ISYM_TIME, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - NULL, NULL, gfc_resolve_time); + add_sym_2 ("this_image", GFC_ISYM_THIS_IMAGE, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F2008, + gfc_check_this_image, gfc_simplify_this_image, gfc_resolve_this_image, + ca, BT_REAL, dr, OPTIONAL, dm, BT_INTEGER, ii, OPTIONAL); + + add_sym_0 ("time", GFC_ISYM_TIME, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, + di, GFC_STD_GNU, NULL, NULL, gfc_resolve_time); make_generic ("time", GFC_ISYM_TIME, GFC_STD_GNU); - add_sym_0 ("time8", GFC_ISYM_TIME8, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - NULL, NULL, gfc_resolve_time8); + add_sym_0 ("time8", GFC_ISYM_TIME8, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, + di, GFC_STD_GNU, NULL, NULL, gfc_resolve_time8); make_generic ("time8", GFC_ISYM_TIME8, GFC_STD_GNU); @@ -2292,6 +2765,13 @@ add_functions (void) make_generic ("tiny", GFC_ISYM_TINY, GFC_STD_F95); + add_sym_1 ("trailz", GFC_ISYM_TRAILZ, CLASS_ELEMENTAL, ACTUAL_NO, + BT_INTEGER, di, GFC_STD_F2008, + gfc_check_i, gfc_simplify_trailz, NULL, + i, BT_INTEGER, di, REQUIRED); + + make_generic ("trailz", GFC_ISYM_TRAILZ, GFC_STD_F2008); + add_sym_3 ("transfer", GFC_ISYM_TRANSFER, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95, gfc_check_transfer, gfc_simplify_transfer, gfc_resolve_transfer, src, BT_REAL, dr, REQUIRED, mo, BT_REAL, dr, REQUIRED, @@ -2300,7 +2780,7 @@ add_functions (void) make_generic ("transfer", GFC_ISYM_TRANSFER, GFC_STD_F95); add_sym_1 ("transpose", GFC_ISYM_TRANSPOSE, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95, - gfc_check_transpose, NULL, gfc_resolve_transpose, + gfc_check_transpose, gfc_simplify_transpose, gfc_resolve_transpose, m, BT_REAL, dr, REQUIRED); make_generic ("transpose", GFC_ISYM_TRANSPOSE, GFC_STD_F95); @@ -2311,8 +2791,8 @@ add_functions (void) make_generic ("trim", GFC_ISYM_TRIM, GFC_STD_F95); - add_sym_1 ("ttynam", GFC_ISYM_TTYNAM, NO_CLASS, ACTUAL_NO, BT_CHARACTER, 0, GFC_STD_GNU, - gfc_check_ttynam, NULL, gfc_resolve_ttynam, + add_sym_1 ("ttynam", GFC_ISYM_TTYNAM, CLASS_IMPURE, ACTUAL_NO, BT_CHARACTER, + 0, GFC_STD_GNU, gfc_check_ttynam, NULL, gfc_resolve_ttynam, ut, BT_INTEGER, di, REQUIRED); make_generic ("ttynam", GFC_ISYM_TTYNAM, GFC_STD_GNU); @@ -2325,22 +2805,30 @@ add_functions (void) make_generic ("ubound", GFC_ISYM_UBOUND, GFC_STD_F95); + add_sym_3 ("ucobound", GFC_ISYM_UCOBOUND, CLASS_INQUIRY, ACTUAL_NO, + BT_INTEGER, di, GFC_STD_F2008, + gfc_check_ucobound, gfc_simplify_ucobound, gfc_resolve_ucobound, + ca, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL, + kind, BT_INTEGER, di, OPTIONAL); + + make_generic ("ucobound", GFC_ISYM_UCOBOUND, GFC_STD_F2008); + /* g77 compatibility for UMASK. */ - add_sym_1 ("umask", GFC_ISYM_UMASK, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_umask, NULL, gfc_resolve_umask, - a, BT_INTEGER, di, REQUIRED); + add_sym_1 ("umask", GFC_ISYM_UMASK, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, di, + GFC_STD_GNU, gfc_check_umask, NULL, gfc_resolve_umask, + msk, BT_INTEGER, di, REQUIRED); make_generic ("umask", GFC_ISYM_UMASK, GFC_STD_GNU); /* g77 compatibility for UNLINK. */ - add_sym_1 ("unlink", GFC_ISYM_UNLINK, NO_CLASS, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, - gfc_check_unlink, NULL, gfc_resolve_unlink, - a, BT_CHARACTER, dc, REQUIRED); + add_sym_1 ("unlink", GFC_ISYM_UNLINK, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, + di, GFC_STD_GNU, gfc_check_unlink, NULL, gfc_resolve_unlink, + "path", BT_CHARACTER, dc, REQUIRED); make_generic ("unlink", GFC_ISYM_UNLINK, GFC_STD_GNU); add_sym_3 ("unpack", GFC_ISYM_UNPACK, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95, - gfc_check_unpack, NULL, gfc_resolve_unpack, + gfc_check_unpack, gfc_simplify_unpack, gfc_resolve_unpack, v, BT_REAL, dr, REQUIRED, msk, BT_LOGICAL, dl, REQUIRED, f, BT_REAL, dr, REQUIRED); @@ -2354,9 +2842,9 @@ add_functions (void) make_generic ("verify", GFC_ISYM_VERIFY, GFC_STD_F95); - add_sym_1 ("loc", GFC_ISYM_LOC, NO_CLASS, ACTUAL_NO, BT_INTEGER, ii, GFC_STD_GNU, - gfc_check_loc, NULL, gfc_resolve_loc, - ar, BT_UNKNOWN, 0, REQUIRED); + add_sym_1 ("loc", GFC_ISYM_LOC, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, ii, + GFC_STD_GNU, gfc_check_loc, NULL, gfc_resolve_loc, + x, BT_UNKNOWN, 0, REQUIRED); make_generic ("loc", GFC_ISYM_LOC, GFC_STD_GNU); } @@ -2377,7 +2865,8 @@ add_subroutines (void) *val = "value", *num = "number", *name = "name", *trim_name = "trim_name", *ut = "unit", *han = "handler", *sec = "seconds", *res = "result", *of = "offset", *md = "mode", - *whence = "whence", *pos = "pos"; + *whence = "whence", *pos = "pos", *ptr = "ptr", *p1 = "path1", + *p2 = "path2", *msk = "mask", *old = "old"; int di, dr, dc, dl, ii; @@ -2391,247 +2880,316 @@ add_subroutines (void) make_noreturn(); - add_sym_1s ("cpu_time", GFC_ISYM_CPU_TIME, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_F95, - gfc_check_cpu_time, NULL, gfc_resolve_cpu_time, - tm, BT_REAL, dr, REQUIRED); + add_sym_2s ("atomic_define", GFC_ISYM_ATOMIC_DEF, CLASS_ATOMIC, + BT_UNKNOWN, 0, GFC_STD_F2008, + gfc_check_atomic_def, NULL, gfc_resolve_atomic_def, + "atom", BT_INTEGER, di, REQUIRED, INTENT_OUT, + "value", BT_INTEGER, di, REQUIRED, INTENT_IN); + + add_sym_2s ("atomic_ref", GFC_ISYM_ATOMIC_REF, CLASS_ATOMIC, + BT_UNKNOWN, 0, GFC_STD_F2008, + gfc_check_atomic_ref, NULL, gfc_resolve_atomic_ref, + "value", BT_INTEGER, di, REQUIRED, INTENT_OUT, + "atom", BT_INTEGER, di, REQUIRED, INTENT_IN); + + add_sym_1s ("cpu_time", GFC_ISYM_CPU_TIME, CLASS_IMPURE, BT_UNKNOWN, 0, + GFC_STD_F95, gfc_check_cpu_time, NULL, gfc_resolve_cpu_time, + tm, BT_REAL, dr, REQUIRED, INTENT_OUT); /* More G77 compatibility garbage. */ - add_sym_2s ("ctime", GFC_ISYM_CTIME, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_2s ("ctime", GFC_ISYM_CTIME, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_ctime_sub, NULL, gfc_resolve_ctime_sub, - tm, BT_INTEGER, di, REQUIRED, res, BT_CHARACTER, dc, REQUIRED); + tm, BT_INTEGER, di, REQUIRED, INTENT_IN, + res, BT_CHARACTER, dc, REQUIRED, INTENT_OUT); - add_sym_1s ("idate", GFC_ISYM_IDATE, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_1s ("idate", GFC_ISYM_IDATE, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_itime_idate, NULL, gfc_resolve_idate, - vl, BT_INTEGER, 4, REQUIRED); + vl, BT_INTEGER, 4, REQUIRED, INTENT_OUT); - add_sym_1s ("itime", GFC_ISYM_ITIME, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_1s ("itime", GFC_ISYM_ITIME, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_itime_idate, NULL, gfc_resolve_itime, - vl, BT_INTEGER, 4, REQUIRED); + vl, BT_INTEGER, 4, REQUIRED, INTENT_OUT); - add_sym_2s ("ltime", GFC_ISYM_LTIME, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_2s ("ltime", GFC_ISYM_LTIME, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_ltime_gmtime, NULL, gfc_resolve_ltime, - tm, BT_INTEGER, di, REQUIRED, vl, BT_INTEGER, di, REQUIRED); + tm, BT_INTEGER, di, REQUIRED, INTENT_IN, + vl, BT_INTEGER, di, REQUIRED, INTENT_OUT); - add_sym_2s ("gmtime", GFC_ISYM_GMTIME, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - gfc_check_ltime_gmtime, NULL, gfc_resolve_gmtime, - tm, BT_INTEGER, di, REQUIRED, vl, BT_INTEGER, di, REQUIRED); + add_sym_2s ("gmtime", GFC_ISYM_GMTIME, CLASS_IMPURE, BT_UNKNOWN, 0, + GFC_STD_GNU, gfc_check_ltime_gmtime, NULL, gfc_resolve_gmtime, + tm, BT_INTEGER, di, REQUIRED, INTENT_IN, + vl, BT_INTEGER, di, REQUIRED, INTENT_OUT); - add_sym_1s ("second", GFC_ISYM_SECOND, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - gfc_check_second_sub, NULL, gfc_resolve_second_sub, - tm, BT_REAL, dr, REQUIRED); + add_sym_1s ("second", GFC_ISYM_SECOND, CLASS_IMPURE, BT_UNKNOWN, 0, + GFC_STD_GNU, gfc_check_second_sub, NULL, gfc_resolve_second_sub, + tm, BT_REAL, dr, REQUIRED, INTENT_OUT); - add_sym_2s ("chdir", GFC_ISYM_CHDIR, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_2s ("chdir", GFC_ISYM_CHDIR, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_chdir_sub, NULL, gfc_resolve_chdir_sub, - name, BT_CHARACTER, dc, REQUIRED, st, BT_INTEGER, di, OPTIONAL); + name, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_3s ("chmod", GFC_ISYM_CHMOD, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_3s ("chmod", GFC_ISYM_CHMOD, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_chmod_sub, NULL, gfc_resolve_chmod_sub, - name, BT_CHARACTER, dc, REQUIRED, md, BT_CHARACTER, dc, REQUIRED, - st, BT_INTEGER, di, OPTIONAL); + name, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + md, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_4s ("date_and_time", GFC_ISYM_DATE_AND_TIME, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_F95, - gfc_check_date_and_time, NULL, NULL, - dt, BT_CHARACTER, dc, OPTIONAL, tm, BT_CHARACTER, dc, OPTIONAL, - zn, BT_CHARACTER, dc, OPTIONAL, vl, BT_INTEGER, di, OPTIONAL); + add_sym_4s ("date_and_time", GFC_ISYM_DATE_AND_TIME, CLASS_IMPURE, BT_UNKNOWN, + 0, GFC_STD_F95, gfc_check_date_and_time, NULL, NULL, + dt, BT_CHARACTER, dc, OPTIONAL, INTENT_OUT, + tm, BT_CHARACTER, dc, OPTIONAL, INTENT_OUT, + zn, BT_CHARACTER, dc, OPTIONAL, INTENT_OUT, + vl, BT_INTEGER, di, OPTIONAL, INTENT_OUT); /* More G77 compatibility garbage. */ - add_sym_2s ("etime", GFC_ISYM_ETIME, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - gfc_check_etime_sub, NULL, gfc_resolve_etime_sub, - vl, BT_REAL, 4, REQUIRED, tm, BT_REAL, 4, REQUIRED); - - add_sym_2s ("dtime", GFC_ISYM_DTIME, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - gfc_check_etime_sub, NULL, gfc_resolve_etime_sub, - vl, BT_REAL, 4, REQUIRED, tm, BT_REAL, 4, REQUIRED); - - add_sym_1s ("fdate", GFC_ISYM_FDATE, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_2s ("etime", GFC_ISYM_ETIME, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, + gfc_check_dtime_etime_sub, NULL, gfc_resolve_etime_sub, + vl, BT_REAL, 4, REQUIRED, INTENT_OUT, + tm, BT_REAL, 4, REQUIRED, INTENT_OUT); + + add_sym_2s ("dtime", GFC_ISYM_DTIME, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, + gfc_check_dtime_etime_sub, NULL, gfc_resolve_dtime_sub, + vl, BT_REAL, 4, REQUIRED, INTENT_OUT, + tm, BT_REAL, 4, REQUIRED, INTENT_OUT); + + add_sym_5s ("execute_command_line", GFC_ISYM_EXECUTE_COMMAND_LINE, + CLASS_IMPURE , BT_UNKNOWN, 0, GFC_STD_F2008, + NULL, NULL, gfc_resolve_execute_command_line, + "command", BT_CHARACTER, dc, REQUIRED, INTENT_IN, + "wait", BT_LOGICAL, dl, OPTIONAL, INTENT_IN, + "exitstat", BT_INTEGER, di, OPTIONAL, INTENT_INOUT, + "cmdstat", BT_INTEGER, di, OPTIONAL, INTENT_OUT, + "cmdmsg", BT_CHARACTER, dc, OPTIONAL, INTENT_INOUT); + + add_sym_1s ("fdate", GFC_ISYM_FDATE, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_fdate_sub, NULL, gfc_resolve_fdate_sub, - dt, BT_CHARACTER, dc, REQUIRED); + dt, BT_CHARACTER, dc, REQUIRED, INTENT_OUT); - add_sym_1s ("gerror", GFC_ISYM_GERROR, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - gfc_check_gerror, NULL, gfc_resolve_gerror, res, BT_CHARACTER, - dc, REQUIRED); + add_sym_1s ("gerror", GFC_ISYM_GERROR, CLASS_IMPURE, BT_UNKNOWN, + 0, GFC_STD_GNU, gfc_check_gerror, NULL, gfc_resolve_gerror, + res, BT_CHARACTER, dc, REQUIRED, INTENT_OUT); - add_sym_2s ("getcwd", GFC_ISYM_GETCWD, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - gfc_check_getcwd_sub, NULL, gfc_resolve_getcwd_sub, - c, BT_CHARACTER, dc, REQUIRED, st, BT_INTEGER, di, OPTIONAL); + add_sym_2s ("getcwd", GFC_ISYM_GETCWD, CLASS_IMPURE, BT_UNKNOWN, 0, + GFC_STD_GNU, gfc_check_getcwd_sub, NULL, gfc_resolve_getcwd_sub, + c, BT_CHARACTER, dc, REQUIRED, INTENT_OUT, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_2s ("getenv", GFC_ISYM_GETENV, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - NULL, NULL, NULL, - name, BT_CHARACTER, dc, REQUIRED, val, BT_CHARACTER, dc, - REQUIRED); + add_sym_2s ("getenv", GFC_ISYM_GETENV, CLASS_IMPURE, BT_UNKNOWN, + 0, GFC_STD_GNU, NULL, NULL, NULL, + name, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + val, BT_CHARACTER, dc, REQUIRED, INTENT_OUT); - add_sym_2s ("getarg", GFC_ISYM_GETARG, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - gfc_check_getarg, NULL, gfc_resolve_getarg, - pos, BT_INTEGER, di, REQUIRED, val, BT_CHARACTER, dc, REQUIRED); + add_sym_2s ("getarg", GFC_ISYM_GETARG, CLASS_IMPURE, BT_UNKNOWN, + 0, GFC_STD_GNU, gfc_check_getarg, NULL, gfc_resolve_getarg, + pos, BT_INTEGER, di, REQUIRED, INTENT_IN, + val, BT_CHARACTER, dc, REQUIRED, INTENT_OUT); - add_sym_1s ("getlog", GFC_ISYM_GETLOG, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - gfc_check_getlog, NULL, gfc_resolve_getlog, c, BT_CHARACTER, - dc, REQUIRED); + add_sym_1s ("getlog", GFC_ISYM_GETLOG, CLASS_IMPURE, BT_UNKNOWN, + 0, GFC_STD_GNU, gfc_check_getlog, NULL, gfc_resolve_getlog, + c, BT_CHARACTER, dc, REQUIRED, INTENT_OUT); /* F2003 commandline routines. */ - add_sym_3s ("get_command", GFC_ISYM_GET_COMMAND, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_F2003, + add_sym_3s ("get_command", GFC_ISYM_GET_COMMAND, CLASS_IMPURE, + BT_UNKNOWN, 0, GFC_STD_F2003, NULL, NULL, gfc_resolve_get_command, - com, BT_CHARACTER, dc, OPTIONAL, - length, BT_INTEGER, di, OPTIONAL, - st, BT_INTEGER, di, OPTIONAL); - - add_sym_4s ("get_command_argument", GFC_ISYM_GET_COMMAND_ARGUMENT, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_F2003, - NULL, NULL, gfc_resolve_get_command_argument, - num, BT_INTEGER, di, REQUIRED, val, BT_CHARACTER, dc, OPTIONAL, - length, BT_INTEGER, di, OPTIONAL, st, BT_INTEGER, di, OPTIONAL); + com, BT_CHARACTER, dc, OPTIONAL, INTENT_OUT, + length, BT_INTEGER, di, OPTIONAL, INTENT_OUT, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); + + add_sym_4s ("get_command_argument", GFC_ISYM_GET_COMMAND_ARGUMENT, + CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_F2003, NULL, NULL, + gfc_resolve_get_command_argument, + num, BT_INTEGER, di, REQUIRED, INTENT_IN, + val, BT_CHARACTER, dc, OPTIONAL, INTENT_OUT, + length, BT_INTEGER, di, OPTIONAL, INTENT_OUT, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); /* F2003 subroutine to get environment variables. */ - add_sym_5s ("get_environment_variable", GFC_ISYM_GET_ENVIRONMENT_VARIABLE, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_F2003, + add_sym_5s ("get_environment_variable", GFC_ISYM_GET_ENVIRONMENT_VARIABLE, + CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_F2003, NULL, NULL, gfc_resolve_get_environment_variable, - name, BT_CHARACTER, dc, REQUIRED, - val, BT_CHARACTER, dc, OPTIONAL, - length, BT_INTEGER, di, OPTIONAL, st, BT_INTEGER, di, OPTIONAL, - trim_name, BT_LOGICAL, dl, OPTIONAL); - - add_sym_2s ("move_alloc", GFC_ISYM_MOVE_ALLOC, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_F2003, + name, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + val, BT_CHARACTER, dc, OPTIONAL, INTENT_OUT, + length, BT_INTEGER, di, OPTIONAL, INTENT_OUT, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT, + trim_name, BT_LOGICAL, dl, OPTIONAL, INTENT_IN); + + add_sym_2s ("move_alloc", GFC_ISYM_MOVE_ALLOC, CLASS_PURE, BT_UNKNOWN, 0, + GFC_STD_F2003, gfc_check_move_alloc, NULL, NULL, - f, BT_UNKNOWN, 0, REQUIRED, - t, BT_UNKNOWN, 0, REQUIRED); - - add_sym_5s ("mvbits", GFC_ISYM_MVBITS, CLASS_ELEMENTAL, BT_UNKNOWN, 0, GFC_STD_F95, - gfc_check_mvbits, gfc_simplify_mvbits, gfc_resolve_mvbits, - f, BT_INTEGER, di, REQUIRED, fp, BT_INTEGER, di, REQUIRED, - ln, BT_INTEGER, di, REQUIRED, t, BT_INTEGER, di, REQUIRED, - tp, BT_INTEGER, di, REQUIRED); - - add_sym_1s ("random_number", GFC_ISYM_RANDOM_NUMBER, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_F95, + f, BT_UNKNOWN, 0, REQUIRED, INTENT_INOUT, + t, BT_UNKNOWN, 0, REQUIRED, INTENT_OUT); + + add_sym_5s ("mvbits", GFC_ISYM_MVBITS, CLASS_ELEMENTAL, BT_UNKNOWN, 0, + GFC_STD_F95, gfc_check_mvbits, gfc_simplify_mvbits, + gfc_resolve_mvbits, + f, BT_INTEGER, di, REQUIRED, INTENT_IN, + fp, BT_INTEGER, di, REQUIRED, INTENT_IN, + ln, BT_INTEGER, di, REQUIRED, INTENT_IN, + t, BT_INTEGER, di, REQUIRED, INTENT_INOUT, + tp, BT_INTEGER, di, REQUIRED, INTENT_IN); + + add_sym_1s ("random_number", GFC_ISYM_RANDOM_NUMBER, CLASS_IMPURE, + BT_UNKNOWN, 0, GFC_STD_F95, gfc_check_random_number, NULL, gfc_resolve_random_number, - h, BT_REAL, dr, REQUIRED); + h, BT_REAL, dr, REQUIRED, INTENT_OUT); - add_sym_3s ("random_seed", GFC_ISYM_RANDOM_SEED, NO_CLASS, + add_sym_3s ("random_seed", GFC_ISYM_RANDOM_SEED, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_F95, gfc_check_random_seed, NULL, gfc_resolve_random_seed, - sz, BT_INTEGER, di, OPTIONAL, pt, BT_INTEGER, di, OPTIONAL, - gt, BT_INTEGER, di, OPTIONAL); + sz, BT_INTEGER, di, OPTIONAL, INTENT_OUT, + pt, BT_INTEGER, di, OPTIONAL, INTENT_IN, + gt, BT_INTEGER, di, OPTIONAL, INTENT_OUT); /* More G77 compatibility garbage. */ - add_sym_3s ("alarm", GFC_ISYM_ALARM, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_3s ("alarm", GFC_ISYM_ALARM, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_alarm_sub, NULL, gfc_resolve_alarm_sub, - sec, BT_INTEGER, di, REQUIRED, han, BT_UNKNOWN, 0, REQUIRED, - st, BT_INTEGER, di, OPTIONAL); + sec, BT_INTEGER, di, REQUIRED, INTENT_IN, + han, BT_UNKNOWN, 0, REQUIRED, INTENT_IN, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_1s ("srand", GFC_ISYM_SRAND, NO_CLASS, BT_UNKNOWN, di, GFC_STD_GNU, - gfc_check_srand, NULL, gfc_resolve_srand, - c, BT_INTEGER, 4, REQUIRED); + add_sym_1s ("srand", GFC_ISYM_SRAND, CLASS_IMPURE, BT_UNKNOWN, + di, GFC_STD_GNU, gfc_check_srand, NULL, gfc_resolve_srand, + "seed", BT_INTEGER, 4, REQUIRED, INTENT_IN); - add_sym_1s ("exit", GFC_ISYM_EXIT, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_1s ("exit", GFC_ISYM_EXIT, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_exit, NULL, gfc_resolve_exit, - st, BT_INTEGER, di, OPTIONAL); + st, BT_INTEGER, di, OPTIONAL, INTENT_IN); make_noreturn(); - add_sym_3s ("fgetc", GFC_ISYM_FGETC, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_3s ("fgetc", GFC_ISYM_FGETC, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_fgetputc_sub, NULL, gfc_resolve_fgetc_sub, - ut, BT_INTEGER, di, REQUIRED, c, BT_CHARACTER, dc, REQUIRED, - st, BT_INTEGER, di, OPTIONAL); + ut, BT_INTEGER, di, REQUIRED, INTENT_IN, + c, BT_CHARACTER, dc, REQUIRED, INTENT_OUT, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_2s ("fget", GFC_ISYM_FGET, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_2s ("fget", GFC_ISYM_FGET, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_fgetput_sub, NULL, gfc_resolve_fget_sub, - c, BT_CHARACTER, dc, REQUIRED, st, BT_INTEGER, di, OPTIONAL); + c, BT_CHARACTER, dc, REQUIRED, INTENT_OUT, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_1s ("flush", GFC_ISYM_FLUSH, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_1s ("flush", GFC_ISYM_FLUSH, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_flush, NULL, gfc_resolve_flush, - c, BT_INTEGER, di, OPTIONAL); + ut, BT_INTEGER, di, OPTIONAL, INTENT_IN); - add_sym_3s ("fputc", GFC_ISYM_FPUTC, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_3s ("fputc", GFC_ISYM_FPUTC, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_fgetputc_sub, NULL, gfc_resolve_fputc_sub, - ut, BT_INTEGER, di, REQUIRED, c, BT_CHARACTER, dc, REQUIRED, - st, BT_INTEGER, di, OPTIONAL); + ut, BT_INTEGER, di, REQUIRED, INTENT_IN, + c, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_2s ("fput", GFC_ISYM_FPUT, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_2s ("fput", GFC_ISYM_FPUT, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_fgetput_sub, NULL, gfc_resolve_fput_sub, - c, BT_CHARACTER, dc, REQUIRED, st, BT_INTEGER, di, OPTIONAL); + c, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_1s ("free", GFC_ISYM_FREE, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_free, - NULL, gfc_resolve_free, c, BT_INTEGER, ii, REQUIRED); + add_sym_1s ("free", GFC_ISYM_FREE, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, + gfc_check_free, NULL, gfc_resolve_free, + ptr, BT_INTEGER, ii, REQUIRED, INTENT_INOUT); - add_sym_4s ("fseek", GFC_ISYM_FSEEK, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - gfc_check_fseek_sub, NULL, gfc_resolve_fseek_sub, - ut, BT_INTEGER, di, REQUIRED, of, BT_INTEGER, di, REQUIRED, - whence, BT_INTEGER, di, REQUIRED, st, BT_INTEGER, di, OPTIONAL); + add_sym_4s ("fseek", GFC_ISYM_FSEEK, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, + gfc_check_fseek_sub, NULL, gfc_resolve_fseek_sub, + ut, BT_INTEGER, di, REQUIRED, INTENT_IN, + of, BT_INTEGER, di, REQUIRED, INTENT_IN, + whence, BT_INTEGER, di, REQUIRED, INTENT_IN, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_2s ("ftell", GFC_ISYM_FTELL, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_2s ("ftell", GFC_ISYM_FTELL, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_ftell_sub, NULL, gfc_resolve_ftell_sub, - ut, BT_INTEGER, di, REQUIRED, of, BT_INTEGER, ii, REQUIRED); + ut, BT_INTEGER, di, REQUIRED, INTENT_IN, + of, BT_INTEGER, ii, REQUIRED, INTENT_OUT); - add_sym_2s ("hostnm", GFC_ISYM_HOSTNM, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - gfc_check_hostnm_sub, NULL, gfc_resolve_hostnm_sub, - c, BT_CHARACTER, dc, REQUIRED, st, BT_INTEGER, di, OPTIONAL); + add_sym_2s ("hostnm", GFC_ISYM_HOSTNM, CLASS_IMPURE, BT_UNKNOWN, 0, + GFC_STD_GNU, gfc_check_hostnm_sub, NULL, gfc_resolve_hostnm_sub, + c, BT_CHARACTER, dc, REQUIRED, INTENT_OUT, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_3s ("kill", GFC_ISYM_KILL, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_kill_sub, - NULL, gfc_resolve_kill_sub, c, BT_INTEGER, di, REQUIRED, - val, BT_INTEGER, di, REQUIRED, st, BT_INTEGER, di, OPTIONAL); + add_sym_3s ("kill", GFC_ISYM_KILL, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, + gfc_check_kill_sub, NULL, gfc_resolve_kill_sub, + c, BT_INTEGER, di, REQUIRED, INTENT_IN, + val, BT_INTEGER, di, REQUIRED, INTENT_IN, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_3s ("link", GFC_ISYM_LINK, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_3s ("link", GFC_ISYM_LINK, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_link_sub, NULL, gfc_resolve_link_sub, - name, BT_CHARACTER, dc, REQUIRED, val, BT_CHARACTER, - dc, REQUIRED, st, BT_INTEGER, di, OPTIONAL); + p1, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + p2, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_1s ("perror", GFC_ISYM_PERROR, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - gfc_check_perror, NULL, gfc_resolve_perror, - c, BT_CHARACTER, dc, REQUIRED); + add_sym_1s ("perror", GFC_ISYM_PERROR, CLASS_IMPURE, BT_UNKNOWN, + 0, GFC_STD_GNU, gfc_check_perror, NULL, gfc_resolve_perror, + "string", BT_CHARACTER, dc, REQUIRED, INTENT_IN); - add_sym_3s ("rename", GFC_ISYM_RENAME, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - gfc_check_rename_sub, NULL, gfc_resolve_rename_sub, - name, BT_CHARACTER, dc, REQUIRED, val, BT_CHARACTER, - dc, REQUIRED, st, BT_INTEGER, di, OPTIONAL); + add_sym_3s ("rename", GFC_ISYM_RENAME, CLASS_IMPURE, BT_UNKNOWN, 0, + GFC_STD_GNU, gfc_check_rename_sub, NULL, gfc_resolve_rename_sub, + p1, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + p2, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_1s ("sleep", GFC_ISYM_SLEEP, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_1s ("sleep", GFC_ISYM_SLEEP, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_sleep_sub, NULL, gfc_resolve_sleep_sub, - val, BT_CHARACTER, dc, REQUIRED); + sec, BT_INTEGER, di, REQUIRED, INTENT_IN); - add_sym_3s ("fstat", GFC_ISYM_FSTAT, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_3s ("fstat", GFC_ISYM_FSTAT, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_fstat_sub, NULL, gfc_resolve_fstat_sub, - ut, BT_INTEGER, di, REQUIRED, vl, BT_INTEGER, di, REQUIRED, - st, BT_INTEGER, di, OPTIONAL); + ut, BT_INTEGER, di, REQUIRED, INTENT_IN, + vl, BT_INTEGER, di, REQUIRED, INTENT_OUT, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_3s ("lstat", GFC_ISYM_LSTAT, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_3s ("lstat", GFC_ISYM_LSTAT, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_stat_sub, NULL, gfc_resolve_lstat_sub, - name, BT_CHARACTER, dc, REQUIRED, vl, BT_INTEGER, di, REQUIRED, - st, BT_INTEGER, di, OPTIONAL); + name, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + vl, BT_INTEGER, di, REQUIRED, INTENT_OUT, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_3s ("stat", GFC_ISYM_STAT, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_3s ("stat", GFC_ISYM_STAT, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_stat_sub, NULL, gfc_resolve_stat_sub, - name, BT_CHARACTER, dc, REQUIRED, vl, BT_INTEGER, di, REQUIRED, - st, BT_INTEGER, di, OPTIONAL); - - add_sym_3s ("signal", GFC_ISYM_SIGNAL, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - gfc_check_signal_sub, NULL, gfc_resolve_signal_sub, - num, BT_INTEGER, di, REQUIRED, han, BT_UNKNOWN, 0, REQUIRED, - st, BT_INTEGER, di, OPTIONAL); - - add_sym_3s ("symlnk", GFC_ISYM_SYMLINK, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - gfc_check_symlnk_sub, NULL, gfc_resolve_symlnk_sub, - name, BT_CHARACTER, dc, REQUIRED, val, BT_CHARACTER, - dc, REQUIRED, st, BT_INTEGER, di, OPTIONAL); - - add_sym_2s ("system", GFC_ISYM_SYSTEM, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - NULL, NULL, gfc_resolve_system_sub, - c, BT_CHARACTER, dc, REQUIRED, st, BT_INTEGER, di, OPTIONAL); - - add_sym_3s ("system_clock", GFC_ISYM_SYSTEM_CLOCK, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_F95, + name, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + vl, BT_INTEGER, di, REQUIRED, INTENT_OUT, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); + + add_sym_3s ("signal", GFC_ISYM_SIGNAL, CLASS_IMPURE, BT_UNKNOWN, 0, + GFC_STD_GNU, gfc_check_signal_sub, NULL, gfc_resolve_signal_sub, + num, BT_INTEGER, di, REQUIRED, INTENT_IN, + han, BT_UNKNOWN, 0, REQUIRED, INTENT_IN, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); + + add_sym_3s ("symlnk", GFC_ISYM_SYMLINK, CLASS_IMPURE, BT_UNKNOWN, 0, + GFC_STD_GNU, gfc_check_symlnk_sub, NULL, gfc_resolve_symlnk_sub, + p1, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + p2, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); + + add_sym_2s ("system", GFC_ISYM_SYSTEM, CLASS_IMPURE, BT_UNKNOWN, + 0, GFC_STD_GNU, NULL, NULL, gfc_resolve_system_sub, + com, BT_CHARACTER, dc, REQUIRED, INTENT_IN, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); + + add_sym_3s ("system_clock", GFC_ISYM_SYSTEM_CLOCK, CLASS_IMPURE, + BT_UNKNOWN, 0, GFC_STD_F95, gfc_check_system_clock, NULL, gfc_resolve_system_clock, - c, BT_INTEGER, di, OPTIONAL, cr, BT_INTEGER, di, OPTIONAL, - cm, BT_INTEGER, di, OPTIONAL); + c, BT_INTEGER, di, OPTIONAL, INTENT_OUT, + cr, BT_INTEGER, di, OPTIONAL, INTENT_OUT, + cm, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_2s ("ttynam", GFC_ISYM_TTYNAM, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - gfc_check_ttynam_sub, NULL, gfc_resolve_ttynam_sub, - ut, BT_INTEGER, di, REQUIRED, name, BT_CHARACTER, dc, REQUIRED); + add_sym_2s ("ttynam", GFC_ISYM_TTYNAM, CLASS_IMPURE, BT_UNKNOWN, 0, + GFC_STD_GNU, gfc_check_ttynam_sub, NULL, gfc_resolve_ttynam_sub, + ut, BT_INTEGER, di, REQUIRED, INTENT_IN, + name, BT_CHARACTER, dc, REQUIRED, INTENT_OUT); - add_sym_2s ("umask", GFC_ISYM_UMASK, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, + add_sym_2s ("umask", GFC_ISYM_UMASK, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU, gfc_check_umask_sub, NULL, gfc_resolve_umask_sub, - val, BT_INTEGER, di, REQUIRED, num, BT_INTEGER, di, OPTIONAL); + msk, BT_INTEGER, di, REQUIRED, INTENT_IN, + old, BT_INTEGER, di, OPTIONAL, INTENT_OUT); - add_sym_2s ("unlink", GFC_ISYM_UNLINK, NO_CLASS, BT_UNKNOWN, 0, GFC_STD_GNU, - gfc_check_unlink_sub, NULL, gfc_resolve_unlink_sub, - c, BT_CHARACTER, dc, REQUIRED, st, BT_INTEGER, di, OPTIONAL); + add_sym_2s ("unlink", GFC_ISYM_UNLINK, CLASS_IMPURE, BT_UNKNOWN, 0, + GFC_STD_GNU, gfc_check_unlink_sub, NULL, gfc_resolve_unlink_sub, + "path", BT_CHARACTER, dc, REQUIRED, INTENT_IN, + st, BT_INTEGER, di, OPTIONAL, INTENT_OUT); } @@ -2664,6 +3222,7 @@ add_conv (bt from_type, int from_kind, bt to_type, int to_kind, int standard) sym->simplify.cc = gfc_convert_constant; sym->standard = standard; sym->elemental = 1; + sym->pure = 1; sym->conversion = 1; sym->ts = to; sym->id = GFC_ISYM_CONVERSION; @@ -2777,12 +3336,57 @@ add_conversions (void) } +static void +add_char_conversions (void) +{ + int n, i, j; + + /* Count possible conversions. */ + for (i = 0; gfc_character_kinds[i].kind != 0; i++) + for (j = 0; gfc_character_kinds[j].kind != 0; j++) + if (i != j) + ncharconv++; + + /* Allocate memory. */ + char_conversions = XCNEWVEC (gfc_intrinsic_sym, ncharconv); + + /* Add the conversions themselves. */ + n = 0; + for (i = 0; gfc_character_kinds[i].kind != 0; i++) + for (j = 0; gfc_character_kinds[j].kind != 0; j++) + { + gfc_typespec from, to; + + if (i == j) + continue; + + gfc_clear_ts (&from); + from.type = BT_CHARACTER; + from.kind = gfc_character_kinds[i].kind; + + gfc_clear_ts (&to); + to.type = BT_CHARACTER; + to.kind = gfc_character_kinds[j].kind; + + char_conversions[n].name = conv_name (&from, &to); + char_conversions[n].lib_name = char_conversions[n].name; + char_conversions[n].simplify.cc = gfc_convert_char_constant; + char_conversions[n].standard = GFC_STD_F2003; + char_conversions[n].elemental = 1; + char_conversions[n].pure = 1; + char_conversions[n].conversion = 0; + char_conversions[n].ts = to; + char_conversions[n].id = GFC_ISYM_CONVERSION; + + n++; + } +} + + /* Initialize the table of intrinsics. */ void gfc_intrinsic_init_1 (void) { - int i; - nargs = nfunc = nsub = nconv = 0; /* Create a namespace to hold the resolved intrinsic symbols. */ @@ -2795,13 +3399,14 @@ gfc_intrinsic_init_1 (void) sizing = SZ_CONVS; add_conversions (); - functions = gfc_getmem (sizeof (gfc_intrinsic_sym) * (nfunc + nsub) - + sizeof (gfc_intrinsic_arg) * nargs); + functions = XCNEWVAR (struct gfc_intrinsic_sym, + sizeof (gfc_intrinsic_sym) * (nfunc + nsub) + + sizeof (gfc_intrinsic_arg) * nargs); next_sym = functions; subroutines = functions + nfunc; - conversion = gfc_getmem (sizeof (gfc_intrinsic_sym) * nconv); + conversion = XCNEWVEC (gfc_intrinsic_sym, nconv); next_arg = ((gfc_intrinsic_arg *) (subroutines + nsub)) - 1; @@ -2812,22 +3417,17 @@ gfc_intrinsic_init_1 (void) add_subroutines (); add_conversions (); - /* Set the pure flag. All intrinsic functions are pure, and - intrinsic subroutines are pure if they are elemental. */ - - for (i = 0; i < nfunc; i++) - functions[i].pure = 1; - - for (i = 0; i < nsub; i++) - subroutines[i].pure = subroutines[i].elemental; + /* Character conversion intrinsics need to be treated separately. */ + add_char_conversions (); } void gfc_intrinsic_done_1 (void) { - gfc_free (functions); - gfc_free (conversion); + free (functions); + free (conversion); + free (char_conversions); gfc_free_namespace (gfc_intrinsic_namespace); } @@ -2877,7 +3477,7 @@ remove_nullargs (gfc_actual_arglist **ap) wrong (say, a missing required argument) we abort sorting and return FAILURE. */ -static try +static gfc_try sort_actual (const char *name, gfc_actual_arglist **ap, gfc_intrinsic_arg *formal, locus *where) { @@ -2940,7 +3540,7 @@ keywords: if (f->actual != NULL) { - gfc_error ("Argument '%s' is appears twice in call to '%s' at %L", + gfc_error ("Argument '%s' appears twice in call to '%s' at %L", f->name, name, where); return FAILURE; } @@ -2998,7 +3598,7 @@ do_sort: list. The lists are checked for agreement of type. We don't check for arrayness here. */ -static try +static gfc_try check_arglist (gfc_actual_arglist **ap, gfc_intrinsic_sym *sym, int error_flag) { @@ -3012,19 +3612,40 @@ check_arglist (gfc_actual_arglist **ap, gfc_intrinsic_sym *sym, i = 0; for (; formal; formal = formal->next, actual = actual->next, i++) { + gfc_typespec ts; + if (actual->expr == NULL) continue; - if (!gfc_compare_types (&formal->ts, &actual->expr->ts)) + ts = formal->ts; + + /* A kind of 0 means we don't check for kind. */ + if (ts.kind == 0) + ts.kind = actual->expr->ts.kind; + + if (!gfc_compare_types (&ts, &actual->expr->ts)) { if (error_flag) gfc_error ("Type of argument '%s' in call to '%s' at %L should " - "be %s, not %s", gfc_current_intrinsic_arg[i], + "be %s, not %s", gfc_current_intrinsic_arg[i]->name, gfc_current_intrinsic, &actual->expr->where, gfc_typename (&formal->ts), gfc_typename (&actual->expr->ts)); return FAILURE; } + + /* If the formal argument is INTENT([IN]OUT), check for definability. */ + if (formal->intent == INTENT_INOUT || formal->intent == INTENT_OUT) + { + const char* context = (error_flag + ? _("actual argument to INTENT = OUT/INOUT") + : NULL); + + /* No pointer arguments for intrinsics. */ + if (gfc_check_vardef_context (actual->expr, false, false, context) + == FAILURE) + return FAILURE; + } } return SUCCESS; @@ -3122,7 +3743,7 @@ resolve_intrinsic (gfc_intrinsic_sym *specific, gfc_expr *e) of the simplification, SUCCESS if the simplification worked, even if nothing has changed in the expression itself. */ -static try +static gfc_try do_simplify (gfc_intrinsic_sym *specific, gfc_expr *e) { gfc_expr *result, *a1, *a2, *a3, *a4, *a5; @@ -3159,15 +3780,13 @@ do_simplify (gfc_intrinsic_sym *specific, gfc_expr *e) a1 = arg->expr; arg = arg->next; - if (specific->simplify.cc == gfc_convert_constant) + if (specific->simplify.cc == gfc_convert_constant + || specific->simplify.cc == gfc_convert_char_constant) { - result = gfc_convert_constant (a1, specific->ts.type, specific->ts.kind); + result = specific->simplify.cc (a1, specific->ts.type, specific->ts.kind); goto finish; } - /* TODO: Warn if -pedantic and initialization expression and arg - types not integer or character */ - if (arg == NULL) result = (*specific->simplify.f1) (a1); else @@ -3240,7 +3859,7 @@ init_arglist (gfc_intrinsic_sym *isym) { if (i >= MAX_INTRINSIC_ARGS) gfc_internal_error ("init_arglist(): too many arguments"); - gfc_current_intrinsic_arg[i++] = formal->name; + gfc_current_intrinsic_arg[i++] = formal; } } @@ -3250,11 +3869,11 @@ init_arglist (gfc_intrinsic_sym *isym) intrinsic's formal argument list. Return SUCCESS if the expression and intrinsic match, FAILURE otherwise. */ -static try +static gfc_try check_specific (gfc_intrinsic_sym *specific, gfc_expr *expr, int error_flag) { gfc_actual_arglist *arg, **ap; - try t; + gfc_try t; ap = &expr->value.function.actual; @@ -3282,6 +3901,9 @@ check_specific (gfc_intrinsic_sym *specific, gfc_expr *expr, int error_flag) /* Same here. The difference to the previous case is that we allow a general numeric type. */ t = gfc_check_product_sum (*ap); + else if (specific->check.f3red == gfc_check_transf_bit_intrins) + /* Same as for PRODUCT and SUM, but different checks. */ + t = gfc_check_transf_bit_intrins (*ap); else { if (specific->check.f1 == NULL) @@ -3306,14 +3928,13 @@ check_specific (gfc_intrinsic_sym *specific, gfc_expr *expr, int error_flag) first_expr = arg->expr; for ( ; arg && arg->expr; arg = arg->next, n++) - { - char buffer[80]; - snprintf (buffer, 80, "arguments '%s' and '%s' for intrinsic '%s'", - gfc_current_intrinsic_arg[0], gfc_current_intrinsic_arg[n], - gfc_current_intrinsic); - if (gfc_check_conformance (buffer, first_expr, arg->expr) == FAILURE) - return FAILURE; - } + if (gfc_check_conformance (first_expr, arg->expr, + "arguments '%s' and '%s' for " + "intrinsic '%s'", + gfc_current_intrinsic_arg[0]->name, + gfc_current_intrinsic_arg[n]->name, + gfc_current_intrinsic) == FAILURE) + return FAILURE; } if (t == FAILURE) @@ -3324,21 +3945,86 @@ check_specific (gfc_intrinsic_sym *specific, gfc_expr *expr, int error_flag) /* Check whether an intrinsic belongs to whatever standard the user - has chosen. */ - -static try -check_intrinsic_standard (const char *name, int standard, locus *where) + has chosen, taking also into account -fall-intrinsics. Here, no + warning/error is emitted; but if symstd is not NULL, it is pointed to a + textual representation of the symbols standard status (like + "new in Fortran 2008", "a GNU extension" or "obsolescent in Fortran 95") that + can be used to construct a detailed warning/error message in case of + a FAILURE. */ + +gfc_try +gfc_check_intrinsic_standard (const gfc_intrinsic_sym* isym, + const char** symstd, bool silent, locus where) { - /* Do not warn about GNU-extensions if -std=gnu. */ - if (!gfc_option.warn_nonstd_intrinsics - || (standard == GFC_STD_GNU && gfc_option.warn_std & GFC_STD_GNU)) + const char* symstd_msg; + + /* For -fall-intrinsics, just succeed. */ + if (gfc_option.flag_all_intrinsics) return SUCCESS; - if (gfc_notify_std (standard, "Intrinsic '%s' at %L is not included " - "in the selected standard", name, where) == FAILURE) - return FAILURE; + /* Find the symbol's standard message for later usage. */ + switch (isym->standard) + { + case GFC_STD_F77: + symstd_msg = "available since Fortran 77"; + break; - return SUCCESS; + case GFC_STD_F95_OBS: + symstd_msg = "obsolescent in Fortran 95"; + break; + + case GFC_STD_F95_DEL: + symstd_msg = "deleted in Fortran 95"; + break; + + case GFC_STD_F95: + symstd_msg = "new in Fortran 95"; + break; + + case GFC_STD_F2003: + symstd_msg = "new in Fortran 2003"; + break; + + case GFC_STD_F2008: + symstd_msg = "new in Fortran 2008"; + break; + + case GFC_STD_F2008_TS: + symstd_msg = "new in TS 29113"; + break; + + case GFC_STD_GNU: + symstd_msg = "a GNU Fortran extension"; + break; + + case GFC_STD_LEGACY: + symstd_msg = "for backward compatibility"; + break; + + default: + gfc_internal_error ("Invalid standard code on intrinsic '%s' (%d)", + isym->name, isym->standard); + } + + /* If warning about the standard, warn and succeed. */ + if (gfc_option.warn_std & isym->standard) + { + /* Do only print a warning if not a GNU extension. */ + if (!silent && isym->standard != GFC_STD_GNU) + gfc_warning ("Intrinsic '%s' (is %s) is used at %L", + isym->name, _(symstd_msg), &where); + + return SUCCESS; + } + + /* If allowing the symbol's standard, succeed, too. */ + if (gfc_option.allow_std & isym->standard) + return SUCCESS; + + /* Otherwise, fail. */ + if (symstd) + *symstd = _(symstd_msg); + return FAILURE; } @@ -3367,7 +4053,8 @@ gfc_intrinsic_func_interface (gfc_expr *expr, int error_flag) return (do_simplify (expr->value.function.isym, expr) == FAILURE) ? MATCH_ERROR : MATCH_YES; - gfc_suppress_error = !error_flag; + if (!error_flag) + gfc_push_suppress_errors (); flag = 0; for (actual = expr->value.function.actual; actual; actual = actual->next) @@ -3377,15 +4064,32 @@ gfc_intrinsic_func_interface (gfc_expr *expr, int error_flag) name = expr->symtree->n.sym->name; - isym = specific = gfc_find_function (name); + if (expr->symtree->n.sym->intmod_sym_id) + { + int id = expr->symtree->n.sym->intmod_sym_id; + isym = specific = gfc_intrinsic_function_by_id ((gfc_isym_id) id); + } + else + isym = specific = gfc_find_function (name); + if (isym == NULL) { - gfc_suppress_error = 0; + if (!error_flag) + gfc_pop_suppress_errors (); return MATCH_NO; } - if (check_intrinsic_standard (name, isym->standard, &expr->where) == FAILURE) - return MATCH_ERROR; + if ((isym->id == GFC_ISYM_REAL || isym->id == GFC_ISYM_DBLE + || isym->id == GFC_ISYM_CMPLX) + && gfc_init_expr_flag + && gfc_notify_std (GFC_STD_F2003, "Fortran 2003: Function '%s' " + "as initialization expression at %L", name, + &expr->where) == FAILURE) + { + if (!error_flag) + gfc_pop_suppress_errors (); + return MATCH_ERROR; + } gfc_current_intrinsic_where = &expr->where; @@ -3397,7 +4101,8 @@ gfc_intrinsic_func_interface (gfc_expr *expr, int error_flag) if (gfc_check_min_max (expr->value.function.actual) == SUCCESS) goto got_specific; - gfc_suppress_error = 0; + if (!error_flag) + gfc_pop_suppress_errors (); return MATCH_NO; } @@ -3405,7 +4110,7 @@ gfc_intrinsic_func_interface (gfc_expr *expr, int error_flag) incarnations. If the generic name is also a specific, we check that name last, so that any error message will correspond to the specific. */ - gfc_suppress_error = 1; + gfc_push_suppress_errors (); if (isym->generic) { @@ -3415,15 +4120,19 @@ gfc_intrinsic_func_interface (gfc_expr *expr, int error_flag) if (specific == isym) continue; if (check_specific (specific, expr, 0) == SUCCESS) - goto got_specific; + { + gfc_pop_suppress_errors (); + goto got_specific; + } } } - gfc_suppress_error = !error_flag; + gfc_pop_suppress_errors (); if (check_specific (isym, expr, error_flag) == FAILURE) { - gfc_suppress_error = 0; + if (!error_flag) + gfc_pop_suppress_errors (); return MATCH_NO; } @@ -3433,7 +4142,9 @@ got_specific: expr->value.function.isym = specific; gfc_intrinsic_symbol (expr->symtree->n.sym); - gfc_suppress_error = 0; + if (!error_flag) + gfc_pop_suppress_errors (); + if (do_simplify (specific, expr) == FAILURE) return MATCH_ERROR; @@ -3446,7 +4157,7 @@ got_specific: (4) A reference to an elemental standard intrinsic function, where each argument is an initialization expression */ - if (gfc_init_expr && isym->elemental && flag + if (gfc_init_expr_flag && isym->elemental && flag && gfc_notify_std (GFC_STD_F2003, "Fortran 2003: Elemental function " "as initialization expression with non-integer/non-" "character arguments at %L", &expr->where) == FAILURE) @@ -3473,10 +4184,8 @@ gfc_intrinsic_sub_interface (gfc_code *c, int error_flag) if (isym == NULL) return MATCH_NO; - if (check_intrinsic_standard (name, isym->standard, &c->loc) == FAILURE) - return MATCH_ERROR; - - gfc_suppress_error = !error_flag; + if (!error_flag) + gfc_push_suppress_errors (); init_arglist (isym); @@ -3496,14 +4205,19 @@ gfc_intrinsic_sub_interface (gfc_code *c, int error_flag) /* The subroutine corresponds to an intrinsic. Allow errors to be seen at this point. */ - gfc_suppress_error = 0; + if (!error_flag) + gfc_pop_suppress_errors (); + c->resolved_isym = isym; if (isym->resolve.s1 != NULL) isym->resolve.s1 (c); else - c->resolved_sym = gfc_get_intrinsic_sub_symbol (isym->lib_name); + { + c->resolved_sym = gfc_get_intrinsic_sub_symbol (isym->lib_name); + c->resolved_sym->attr.elemental = isym->elemental; + } - if (gfc_pure (NULL) && !isym->elemental) + if (gfc_pure (NULL) && !isym->pure) { gfc_error ("Subroutine call to intrinsic '%s' at %L is not PURE", name, &c->loc); @@ -3515,14 +4229,15 @@ gfc_intrinsic_sub_interface (gfc_code *c, int error_flag) return MATCH_YES; fail: - gfc_suppress_error = 0; + if (!error_flag) + gfc_pop_suppress_errors (); return MATCH_NO; } /* Call gfc_convert_type() with warning enabled. */ -try +gfc_try gfc_convert_type (gfc_expr *expr, gfc_typespec *ts, int eflag) { return gfc_convert_type_warn (expr, ts, eflag, 1); @@ -3539,13 +4254,13 @@ gfc_convert_type (gfc_expr *expr, gfc_typespec *ts, int eflag) 'wflag' controls the warning related to conversion. */ -try +gfc_try gfc_convert_type_warn (gfc_expr *expr, gfc_typespec *ts, int eflag, int wflag) { gfc_intrinsic_sym *sym; gfc_typespec from_ts; locus old_where; - gfc_expr *new; + gfc_expr *new_expr; int rank; mpz_t *shape; @@ -3576,40 +4291,105 @@ gfc_convert_type_warn (gfc_expr *expr, gfc_typespec *ts, int eflag, int wflag) /* At this point, a conversion is necessary. A warning may be needed. */ if ((gfc_option.warn_std & sym->standard) != 0) - gfc_warning_now ("Extension: Conversion from %s to %s at %L", - gfc_typename (&from_ts), gfc_typename (ts), &expr->where); - else if (wflag && gfc_option.warn_conversion) - gfc_warning_now ("Conversion from %s to %s at %L", - gfc_typename (&from_ts), gfc_typename (ts), &expr->where); + { + gfc_warning_now ("Extension: Conversion from %s to %s at %L", + gfc_typename (&from_ts), gfc_typename (ts), + &expr->where); + } + else if (wflag) + { + if (gfc_option.flag_range_check + && expr->expr_type == EXPR_CONSTANT + && from_ts.type == ts->type) + { + /* Do nothing. Constants of the same type are range-checked + elsewhere. If a value too large for the target type is + assigned, an error is generated. Not checking here avoids + duplications of warnings/errors. + If range checking was disabled, but -Wconversion enabled, + a non range checked warning is generated below. */ + } + else if (from_ts.type == BT_LOGICAL || ts->type == BT_LOGICAL) + { + /* Do nothing. This block exists only to simplify the other + else-if expressions. + LOGICAL <> LOGICAL no warning, independent of kind values + LOGICAL <> INTEGER extension, warned elsewhere + LOGICAL <> REAL invalid, error generated elsewhere + LOGICAL <> COMPLEX invalid, error generated elsewhere */ + } + else if (from_ts.type == ts->type + || (from_ts.type == BT_INTEGER && ts->type == BT_REAL) + || (from_ts.type == BT_INTEGER && ts->type == BT_COMPLEX) + || (from_ts.type == BT_REAL && ts->type == BT_COMPLEX)) + { + /* Larger kinds can hold values of smaller kinds without problems. + Hence, only warn if target kind is smaller than the source + kind - or if -Wconversion-extra is specified. */ + if (gfc_option.warn_conversion_extra) + gfc_warning_now ("Conversion from %s to %s at %L", + gfc_typename (&from_ts), gfc_typename (ts), + &expr->where); + else if (gfc_option.gfc_warn_conversion + && from_ts.kind > ts->kind) + gfc_warning_now ("Possible change of value in conversion " + "from %s to %s at %L", gfc_typename (&from_ts), + gfc_typename (ts), &expr->where); + } + else if ((from_ts.type == BT_REAL && ts->type == BT_INTEGER) + || (from_ts.type == BT_COMPLEX && ts->type == BT_INTEGER) + || (from_ts.type == BT_COMPLEX && ts->type == BT_REAL)) + { + /* Conversion from REAL/COMPLEX to INTEGER or COMPLEX to REAL + usually comes with a loss of information, regardless of kinds. */ + if (gfc_option.warn_conversion_extra + || gfc_option.gfc_warn_conversion) + gfc_warning_now ("Possible change of value in conversion " + "from %s to %s at %L", gfc_typename (&from_ts), + gfc_typename (ts), &expr->where); + } + else if (from_ts.type == BT_HOLLERITH || ts->type == BT_HOLLERITH) + { + /* If HOLLERITH is involved, all bets are off. */ + if (gfc_option.warn_conversion_extra + || gfc_option.gfc_warn_conversion) + gfc_warning_now ("Conversion from %s to %s at %L", + gfc_typename (&from_ts), gfc_typename (ts), + &expr->where); + } + else + gcc_unreachable (); + } /* Insert a pre-resolved function call to the right function. */ old_where = expr->where; rank = expr->rank; shape = expr->shape; - new = gfc_get_expr (); - *new = *expr; - - new = gfc_build_conversion (new); - new->value.function.name = sym->lib_name; - new->value.function.isym = sym; - new->where = old_where; - new->rank = rank; - new->shape = gfc_copy_shape (shape, rank); - - gfc_get_ha_sym_tree (sym->name, &new->symtree); - new->symtree->n.sym->ts = *ts; - new->symtree->n.sym->attr.flavor = FL_PROCEDURE; - new->symtree->n.sym->attr.function = 1; - new->symtree->n.sym->attr.elemental = 1; - new->symtree->n.sym->attr.pure = 1; - new->symtree->n.sym->attr.referenced = 1; - gfc_intrinsic_symbol(new->symtree->n.sym); - gfc_commit_symbol (new->symtree->n.sym); - - *expr = *new; - - gfc_free (new); + new_expr = gfc_get_expr (); + *new_expr = *expr; + + new_expr = gfc_build_conversion (new_expr); + new_expr->value.function.name = sym->lib_name; + new_expr->value.function.isym = sym; + new_expr->where = old_where; + new_expr->rank = rank; + new_expr->shape = gfc_copy_shape (shape, rank); + + gfc_get_ha_sym_tree (sym->name, &new_expr->symtree); + new_expr->symtree->n.sym->result = new_expr->symtree->n.sym; + new_expr->symtree->n.sym->ts = *ts; + new_expr->symtree->n.sym->attr.flavor = FL_PROCEDURE; + new_expr->symtree->n.sym->attr.function = 1; + new_expr->symtree->n.sym->attr.elemental = 1; + new_expr->symtree->n.sym->attr.pure = 1; + new_expr->symtree->n.sym->attr.referenced = 1; + gfc_intrinsic_symbol(new_expr->symtree->n.sym); + gfc_commit_symbol (new_expr->symtree->n.sym); + + *expr = *new_expr; + + free (new_expr); expr->ts = *ts; if (gfc_is_constant_expr (expr->value.function.actual->expr) @@ -3636,3 +4416,96 @@ bad: &expr->where); /* Not reached */ } + + +gfc_try +gfc_convert_chartype (gfc_expr *expr, gfc_typespec *ts) +{ + gfc_intrinsic_sym *sym; + locus old_where; + gfc_expr *new_expr; + int rank; + mpz_t *shape; + + gcc_assert (expr->ts.type == BT_CHARACTER && ts->type == BT_CHARACTER); + + sym = find_char_conv (&expr->ts, ts); + gcc_assert (sym); + + /* Insert a pre-resolved function call to the right function. */ + old_where = expr->where; + rank = expr->rank; + shape = expr->shape; + + new_expr = gfc_get_expr (); + *new_expr = *expr; + + new_expr = gfc_build_conversion (new_expr); + new_expr->value.function.name = sym->lib_name; + new_expr->value.function.isym = sym; + new_expr->where = old_where; + new_expr->rank = rank; + new_expr->shape = gfc_copy_shape (shape, rank); + + gfc_get_ha_sym_tree (sym->name, &new_expr->symtree); + new_expr->symtree->n.sym->ts = *ts; + new_expr->symtree->n.sym->attr.flavor = FL_PROCEDURE; + new_expr->symtree->n.sym->attr.function = 1; + new_expr->symtree->n.sym->attr.elemental = 1; + new_expr->symtree->n.sym->attr.referenced = 1; + gfc_intrinsic_symbol(new_expr->symtree->n.sym); + gfc_commit_symbol (new_expr->symtree->n.sym); + + *expr = *new_expr; + + free (new_expr); + expr->ts = *ts; + + if (gfc_is_constant_expr (expr->value.function.actual->expr) + && do_simplify (sym, expr) == FAILURE) + { + /* Error already generated in do_simplify() */ + return FAILURE; + } + + return SUCCESS; +} + + +/* Check if the passed name is name of an intrinsic (taking into account the + current -std=* and -fall-intrinsic settings). If it is, see if we should + warn about this as a user-procedure having the same name as an intrinsic + (-Wintrinsic-shadow enabled) and do so if we should. */ + +void +gfc_warn_intrinsic_shadow (const gfc_symbol* sym, bool in_module, bool func) +{ + gfc_intrinsic_sym* isym; + + /* If the warning is disabled, do nothing at all. */ + if (!gfc_option.warn_intrinsic_shadow) + return; + + /* Try to find an intrinsic of the same name. */ + if (func) + isym = gfc_find_function (sym->name); + else + isym = gfc_find_subroutine (sym->name); + + /* If no intrinsic was found with this name or it's not included in the + selected standard, everything's fine. */ + if (!isym || gfc_check_intrinsic_standard (isym, NULL, true, + sym->declared_at) == FAILURE) + return; + + /* Emit the warning. */ + if (in_module) + gfc_warning ("'%s' declared at %L may shadow the intrinsic of the same" + " name. In order to call the intrinsic, explicit INTRINSIC" + " declarations may be required.", + sym->name, &sym->declared_at); + else + gfc_warning ("'%s' declared at %L is also the name of an intrinsic. It can" + " only be called via an explicit interface or if declared" + " EXTERNAL.", sym->name, &sym->declared_at); +}