?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[AArch64 costs 7/18] Improve SET cost.
[official-gcc.git] / gcc / fortran / intrinsic.c
blob4c2eaa5f72910094be4436a2877654f11d13c0dc
1 /* Build up a list of intrinsic subroutines and functions for the
2 name-resolution stage.
3 Copyright (C) 2000-2014 Free Software Foundation, Inc.
4 Contributed by Andy Vaught & Katherine Holcomb
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "flags.h"
26 #include "gfortran.h"
27 #include "intrinsic.h"
28
29 /* Namespace to hold the resolved symbols for intrinsic subroutines. */
30 static gfc_namespace *gfc_intrinsic_namespace;
31
32 bool gfc_init_expr_flag = false;
33
34 /* Pointers to an intrinsic function and its argument names that are being
35 checked. */
36
37 const char *gfc_current_intrinsic;
38 gfc_intrinsic_arg *gfc_current_intrinsic_arg[MAX_INTRINSIC_ARGS];
39 locus *gfc_current_intrinsic_where;
40
41 static gfc_intrinsic_sym *functions, *subroutines, *conversion, *next_sym;
42 static gfc_intrinsic_sym *char_conversions;
43 static gfc_intrinsic_arg *next_arg;
44
45 static int nfunc, nsub, nargs, nconv, ncharconv;
46
47 static enum
48 { SZ_NOTHING = 0, SZ_SUBS, SZ_FUNCS, SZ_CONVS }
49 sizing;
50
51 enum klass
52 { CLASS_IMPURE = 0, CLASS_PURE, CLASS_ELEMENTAL,
53 CLASS_INQUIRY, CLASS_TRANSFORMATIONAL, CLASS_ATOMIC };
54
55 #define ACTUAL_NO 0
56 #define ACTUAL_YES 1
57
58 #define REQUIRED 0
59 #define OPTIONAL 1
60
61
62 /* Return a letter based on the passed type. Used to construct the
63 name of a type-dependent subroutine. */
64
65 char
66 gfc_type_letter (bt type)
67 {
68 char c;
69
70 switch (type)
71 {
72 case BT_LOGICAL:
73 c = 'l';
74 break;
75 case BT_CHARACTER:
76 c = 's';
77 break;
78 case BT_INTEGER:
79 c = 'i';
80 break;
81 case BT_REAL:
82 c = 'r';
83 break;
84 case BT_COMPLEX:
85 c = 'c';
86 break;
87
88 case BT_HOLLERITH:
89 c = 'h';
90 break;
91
92 default:
93 c = 'u';
94 break;
95 }
96
97 return c;
98 }
99
100
101 /* Get a symbol for a resolved name. Note, if needed be, the elemental
102 attribute has be added afterwards. */
103
104 gfc_symbol *
105 gfc_get_intrinsic_sub_symbol (const char *name)
106 {
107 gfc_symbol *sym;
108
109 gfc_get_symbol (name, gfc_intrinsic_namespace, &sym);
110 sym->attr.always_explicit = 1;
111 sym->attr.subroutine = 1;
112 sym->attr.flavor = FL_PROCEDURE;
113 sym->attr.proc = PROC_INTRINSIC;
114
115 gfc_commit_symbol (sym);
116
117 return sym;
118 }
119
120
121 /* Return a pointer to the name of a conversion function given two
122 typespecs. */
123
124 static const char *
125 conv_name (gfc_typespec *from, gfc_typespec *to)
126 {
127 return gfc_get_string ("__convert_%c%d_%c%d",
128 gfc_type_letter (from->type), from->kind,
129 gfc_type_letter (to->type), to->kind);
130 }
131
132
133 /* Given a pair of typespecs, find the gfc_intrinsic_sym node that
134 corresponds to the conversion. Returns NULL if the conversion
135 isn't found. */
136
137 static gfc_intrinsic_sym *
138 find_conv (gfc_typespec *from, gfc_typespec *to)
139 {
140 gfc_intrinsic_sym *sym;
141 const char *target;
142 int i;
143
144 target = conv_name (from, to);
145 sym = conversion;
146
147 for (i = 0; i < nconv; i++, sym++)
148 if (target == sym->name)
149 return sym;
150
151 return NULL;
152 }
153
154
155 /* Given a pair of CHARACTER typespecs, find the gfc_intrinsic_sym node
156 that corresponds to the conversion. Returns NULL if the conversion
157 isn't found. */
158
159 static gfc_intrinsic_sym *
160 find_char_conv (gfc_typespec *from, gfc_typespec *to)
161 {
162 gfc_intrinsic_sym *sym;
163 const char *target;
164 int i;
165
166 target = conv_name (from, to);
167 sym = char_conversions;
168
169 for (i = 0; i < ncharconv; i++, sym++)
170 if (target == sym->name)
171 return sym;
172
173 return NULL;
174 }
175
176
177 /* Check TS29113, C407b for assumed type and C535b for assumed-rank,
178 and a likewise check for NO_ARG_CHECK. */
179
180 static bool
181 do_ts29113_check (gfc_intrinsic_sym *specific, gfc_actual_arglist *arg)
182 {
183 gfc_actual_arglist *a;
184
185 for (a = arg; a; a = a->next)
186 {
187 if (!a->expr)
188 continue;
189
190 if (a->expr->expr_type == EXPR_VARIABLE
191 && (a->expr->symtree->n.sym->attr.ext_attr
192 & (1 << EXT_ATTR_NO_ARG_CHECK))
193 && specific->id != GFC_ISYM_C_LOC
194 && specific->id != GFC_ISYM_PRESENT)
195 {
196 gfc_error ("Variable with NO_ARG_CHECK attribute at %L is only "
197 "permitted as argument to the intrinsic functions "
198 "C_LOC and PRESENT", &a->expr->where);
199 return false;
200 }
201 else if (a->expr->ts.type == BT_ASSUMED
202 && specific->id != GFC_ISYM_LBOUND
203 && specific->id != GFC_ISYM_PRESENT
204 && specific->id != GFC_ISYM_RANK
205 && specific->id != GFC_ISYM_SHAPE
206 && specific->id != GFC_ISYM_SIZE
207 && specific->id != GFC_ISYM_UBOUND
208 && specific->id != GFC_ISYM_C_LOC)
209 {
210 gfc_error ("Assumed-type argument at %L is not permitted as actual"
211 " argument to the intrinsic %s", &a->expr->where,
212 gfc_current_intrinsic);
213 return false;
214 }
215 else if (a->expr->ts.type == BT_ASSUMED && a != arg)
216 {
217 gfc_error ("Assumed-type argument at %L is only permitted as "
218 "first actual argument to the intrinsic %s",
219 &a->expr->where, gfc_current_intrinsic);
220 return false;
221 }
222 if (a->expr->rank == -1 && !specific->inquiry)
223 {
224 gfc_error ("Assumed-rank argument at %L is only permitted as actual "
225 "argument to intrinsic inquiry functions",
226 &a->expr->where);
227 return false;
228 }
229 if (a->expr->rank == -1 && arg != a)
230 {
231 gfc_error ("Assumed-rank argument at %L is only permitted as first "
232 "actual argument to the intrinsic inquiry function %s",
233 &a->expr->where, gfc_current_intrinsic);
234 return false;
235 }
236 }
237
238 return true;
239 }
240
241
242 /* Interface to the check functions. We break apart an argument list
243 and call the proper check function rather than forcing each
244 function to manipulate the argument list. */
245
246 static bool
247 do_check (gfc_intrinsic_sym *specific, gfc_actual_arglist *arg)
248 {
249 gfc_expr *a1, *a2, *a3, *a4, *a5;
250
251 if (arg == NULL)
252 return (*specific->check.f0) ();
253
254 a1 = arg->expr;
255 arg = arg->next;
256 if (arg == NULL)
257 return (*specific->check.f1) (a1);
258
259 a2 = arg->expr;
260 arg = arg->next;
261 if (arg == NULL)
262 return (*specific->check.f2) (a1, a2);
263
264 a3 = arg->expr;
265 arg = arg->next;
266 if (arg == NULL)
267 return (*specific->check.f3) (a1, a2, a3);
268
269 a4 = arg->expr;
270 arg = arg->next;
271 if (arg == NULL)
272 return (*specific->check.f4) (a1, a2, a3, a4);
273
274 a5 = arg->expr;
275 arg = arg->next;
276 if (arg == NULL)
277 return (*specific->check.f5) (a1, a2, a3, a4, a5);
278
279 gfc_internal_error ("do_check(): too many args");
280 }
281
282
283 /*********** Subroutines to build the intrinsic list ****************/
284
285 /* Add a single intrinsic symbol to the current list.
286
287 Argument list:
288 char * name of function
289 int whether function is elemental
290 int If the function can be used as an actual argument [1]
291 bt return type of function
292 int kind of return type of function
293 int Fortran standard version
294 check pointer to check function
295 simplify pointer to simplification function
296 resolve pointer to resolution function
297
298 Optional arguments come in multiples of five:
299 char * name of argument
300 bt type of argument
301 int kind of argument
302 int arg optional flag (1=optional, 0=required)
303 sym_intent intent of argument
304
305 The sequence is terminated by a NULL name.
306
307
308 [1] Whether a function can or cannot be used as an actual argument is
309 determined by its presence on the 13.6 list in Fortran 2003. The
310 following intrinsics, which are GNU extensions, are considered allowed
311 as actual arguments: ACOSH ATANH DACOSH DASINH DATANH DCONJG DIMAG
312 ZABS ZCOS ZEXP ZLOG ZSIN ZSQRT. */
313
314 static void
315 add_sym (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type, int kind,
316 int standard, gfc_check_f check, gfc_simplify_f simplify,
317 gfc_resolve_f resolve, ...)
318 {
319 char buf[GFC_MAX_SYMBOL_LEN + 11]; /* 10 for '_gfortran_', 1 for '\0' */
320 int optional, first_flag;
321 sym_intent intent;
322 va_list argp;
323
324 switch (sizing)
325 {
326 case SZ_SUBS:
327 nsub++;
328 break;
329
330 case SZ_FUNCS:
331 nfunc++;
332 break;
333
334 case SZ_NOTHING:
335 next_sym->name = gfc_get_string (name);
336
337 strcpy (buf, "_gfortran_");
338 strcat (buf, name);
339 next_sym->lib_name = gfc_get_string (buf);
340
341 next_sym->pure = (cl != CLASS_IMPURE);
342 next_sym->elemental = (cl == CLASS_ELEMENTAL);
343 next_sym->inquiry = (cl == CLASS_INQUIRY);
344 next_sym->transformational = (cl == CLASS_TRANSFORMATIONAL);
345 next_sym->actual_ok = actual_ok;
346 next_sym->ts.type = type;
347 next_sym->ts.kind = kind;
348 next_sym->standard = standard;
349 next_sym->simplify = simplify;
350 next_sym->check = check;
351 next_sym->resolve = resolve;
352 next_sym->specific = 0;
353 next_sym->generic = 0;
354 next_sym->conversion = 0;
355 next_sym->id = id;
356 break;
357
358 default:
359 gfc_internal_error ("add_sym(): Bad sizing mode");
360 }
361
362 va_start (argp, resolve);
363
364 first_flag = 1;
365
366 for (;;)
367 {
368 name = va_arg (argp, char *);
369 if (name == NULL)
370 break;
371
372 type = (bt) va_arg (argp, int);
373 kind = va_arg (argp, int);
374 optional = va_arg (argp, int);
375 intent = (sym_intent) va_arg (argp, int);
376
377 if (sizing != SZ_NOTHING)
378 nargs++;
379 else
380 {
381 next_arg++;
382
383 if (first_flag)
384 next_sym->formal = next_arg;
385 else
386 (next_arg - 1)->next = next_arg;
387
388 first_flag = 0;
389
390 strcpy (next_arg->name, name);
391 next_arg->ts.type = type;
392 next_arg->ts.kind = kind;
393 next_arg->optional = optional;
394 next_arg->value = 0;
395 next_arg->intent = intent;
396 }
397 }
398
399 va_end (argp);
400
401 next_sym++;
402 }
403
404
405 /* Add a symbol to the function list where the function takes
406 0 arguments. */
407
408 static void
409 add_sym_0 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
410 int kind, int standard,
411 bool (*check) (void),
412 gfc_expr *(*simplify) (void),
413 void (*resolve) (gfc_expr *))
414 {
415 gfc_simplify_f sf;
416 gfc_check_f cf;
417 gfc_resolve_f rf;
418
419 cf.f0 = check;
420 sf.f0 = simplify;
421 rf.f0 = resolve;
422
423 add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf,
424 (void *) 0);
425 }
426
427
428 /* Add a symbol to the subroutine list where the subroutine takes
429 0 arguments. */
430
431 static void
432 add_sym_0s (const char *name, gfc_isym_id id, int standard,
433 void (*resolve) (gfc_code *))
434 {
435 gfc_check_f cf;
436 gfc_simplify_f sf;
437 gfc_resolve_f rf;
438
439 cf.f1 = NULL;
440 sf.f1 = NULL;
441 rf.s1 = resolve;
442
443 add_sym (name, id, CLASS_IMPURE, ACTUAL_NO, BT_UNKNOWN, 0, standard, cf, sf,
444 rf, (void *) 0);
445 }
446
447
448 /* Add a symbol to the function list where the function takes
449 1 arguments. */
450
451 static void
452 add_sym_1 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
453 int kind, int standard,
454 bool (*check) (gfc_expr *),
455 gfc_expr *(*simplify) (gfc_expr *),
456 void (*resolve) (gfc_expr *, gfc_expr *),
457 const char *a1, bt type1, int kind1, int optional1)
458 {
459 gfc_check_f cf;
460 gfc_simplify_f sf;
461 gfc_resolve_f rf;
462
463 cf.f1 = check;
464 sf.f1 = simplify;
465 rf.f1 = resolve;
466
467 add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf,
468 a1, type1, kind1, optional1, INTENT_IN,
469 (void *) 0);
470 }
471
472
473 /* Add a symbol to the function list where the function takes
474 1 arguments, specifying the intent of the argument. */
475
476 static void
477 add_sym_1_intent (const char *name, gfc_isym_id id, enum klass cl,
478 int actual_ok, bt type, int kind, int standard,
479 bool (*check) (gfc_expr *),
480 gfc_expr *(*simplify) (gfc_expr *),
481 void (*resolve) (gfc_expr *, gfc_expr *),
482 const char *a1, bt type1, int kind1, int optional1,
483 sym_intent intent1)
484 {
485 gfc_check_f cf;
486 gfc_simplify_f sf;
487 gfc_resolve_f rf;
488
489 cf.f1 = check;
490 sf.f1 = simplify;
491 rf.f1 = resolve;
492
493 add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf,
494 a1, type1, kind1, optional1, intent1,
495 (void *) 0);
496 }
497
498
499 /* Add a symbol to the subroutine list where the subroutine takes
500 1 arguments, specifying the intent of the argument. */
501
502 static void
503 add_sym_1s (const char *name, gfc_isym_id id, enum klass cl, bt type, int kind,
504 int standard, bool (*check) (gfc_expr *),
505 gfc_expr *(*simplify) (gfc_expr *), void (*resolve) (gfc_code *),
506 const char *a1, bt type1, int kind1, int optional1,
507 sym_intent intent1)
508 {
509 gfc_check_f cf;
510 gfc_simplify_f sf;
511 gfc_resolve_f rf;
512
513 cf.f1 = check;
514 sf.f1 = simplify;
515 rf.s1 = resolve;
516
517 add_sym (name, id, cl, ACTUAL_NO, type, kind, standard, cf, sf, rf,
518 a1, type1, kind1, optional1, intent1,
519 (void *) 0);
520 }
521
522
523 /* Add a symbol from the MAX/MIN family of intrinsic functions to the
524 function. MAX et al take 2 or more arguments. */
525
526 static void
527 add_sym_1m (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
528 int kind, int standard,
529 bool (*check) (gfc_actual_arglist *),
530 gfc_expr *(*simplify) (gfc_expr *),
531 void (*resolve) (gfc_expr *, gfc_actual_arglist *),
532 const char *a1, bt type1, int kind1, int optional1,
533 const char *a2, bt type2, int kind2, int optional2)
534 {
535 gfc_check_f cf;
536 gfc_simplify_f sf;
537 gfc_resolve_f rf;
538
539 cf.f1m = check;
540 sf.f1 = simplify;
541 rf.f1m = resolve;
542
543 add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf,
544 a1, type1, kind1, optional1, INTENT_IN,
545 a2, type2, kind2, optional2, INTENT_IN,
546 (void *) 0);
547 }
548
549
550 /* Add a symbol to the function list where the function takes
551 2 arguments. */
552
553 static void
554 add_sym_2 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
555 int kind, int standard,
556 bool (*check) (gfc_expr *, gfc_expr *),
557 gfc_expr *(*simplify) (gfc_expr *, gfc_expr *),
558 void (*resolve) (gfc_expr *, gfc_expr *, gfc_expr *),
559 const char *a1, bt type1, int kind1, int optional1,
560 const char *a2, bt type2, int kind2, int optional2)
561 {
562 gfc_check_f cf;
563 gfc_simplify_f sf;
564 gfc_resolve_f rf;
565
566 cf.f2 = check;
567 sf.f2 = simplify;
568 rf.f2 = resolve;
569
570 add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf,
571 a1, type1, kind1, optional1, INTENT_IN,
572 a2, type2, kind2, optional2, INTENT_IN,
573 (void *) 0);
574 }
575
576
577 /* Add a symbol to the function list where the function takes
578 2 arguments; same as add_sym_2 - but allows to specify the intent. */
579
580 static void
581 add_sym_2_intent (const char *name, gfc_isym_id id, enum klass cl,
582 int actual_ok, bt type, int kind, int standard,
583 bool (*check) (gfc_expr *, gfc_expr *),
584 gfc_expr *(*simplify) (gfc_expr *, gfc_expr *),
585 void (*resolve) (gfc_expr *, gfc_expr *, gfc_expr *),
586 const char *a1, bt type1, int kind1, int optional1,
587 sym_intent intent1, const char *a2, bt type2, int kind2,
588 int optional2, sym_intent intent2)
589 {
590 gfc_check_f cf;
591 gfc_simplify_f sf;
592 gfc_resolve_f rf;
593
594 cf.f2 = check;
595 sf.f2 = simplify;
596 rf.f2 = resolve;
597
598 add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf,
599 a1, type1, kind1, optional1, intent1,
600 a2, type2, kind2, optional2, intent2,
601 (void *) 0);
602 }
603
604
605 /* Add a symbol to the subroutine list where the subroutine takes
606 2 arguments, specifying the intent of the arguments. */
607
608 static void
609 add_sym_2s (const char *name, gfc_isym_id id, enum klass cl, bt type,
610 int kind, int standard,
611 bool (*check) (gfc_expr *, gfc_expr *),
612 gfc_expr *(*simplify) (gfc_expr *, gfc_expr *),
613 void (*resolve) (gfc_code *),
614 const char *a1, bt type1, int kind1, int optional1,
615 sym_intent intent1, const char *a2, bt type2, int kind2,
616 int optional2, sym_intent intent2)
617 {
618 gfc_check_f cf;
619 gfc_simplify_f sf;
620 gfc_resolve_f rf;
621
622 cf.f2 = check;
623 sf.f2 = simplify;
624 rf.s1 = resolve;
625
626 add_sym (name, id, cl, ACTUAL_NO, type, kind, standard, cf, sf, rf,
627 a1, type1, kind1, optional1, intent1,
628 a2, type2, kind2, optional2, intent2,
629 (void *) 0);
630 }
631
632
633 /* Add a symbol to the function list where the function takes
634 3 arguments. */
635
636 static void
637 add_sym_3 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
638 int kind, int standard,
639 bool (*check) (gfc_expr *, gfc_expr *, gfc_expr *),
640 gfc_expr *(*simplify) (gfc_expr *, gfc_expr *, gfc_expr *),
641 void (*resolve) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *),
642 const char *a1, bt type1, int kind1, int optional1,
643 const char *a2, bt type2, int kind2, int optional2,
644 const char *a3, bt type3, int kind3, int optional3)
645 {
646 gfc_check_f cf;
647 gfc_simplify_f sf;
648 gfc_resolve_f rf;
649
650 cf.f3 = check;
651 sf.f3 = simplify;
652 rf.f3 = resolve;
653
654 add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf,
655 a1, type1, kind1, optional1, INTENT_IN,
656 a2, type2, kind2, optional2, INTENT_IN,
657 a3, type3, kind3, optional3, INTENT_IN,
658 (void *) 0);
659 }
660
661
662 /* MINLOC and MAXLOC get special treatment because their argument
663 might have to be reordered. */
664
665 static void
666 add_sym_3ml (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
667 int kind, int standard,
668 bool (*check) (gfc_actual_arglist *),
669 gfc_expr *(*simplify) (gfc_expr *, gfc_expr *, gfc_expr *),
670 void (*resolve) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *),
671 const char *a1, bt type1, int kind1, int optional1,
672 const char *a2, bt type2, int kind2, int optional2,
673 const char *a3, bt type3, int kind3, int optional3)
674 {
675 gfc_check_f cf;
676 gfc_simplify_f sf;
677 gfc_resolve_f rf;
678
679 cf.f3ml = check;
680 sf.f3 = simplify;
681 rf.f3 = resolve;
682
683 add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf,
684 a1, type1, kind1, optional1, INTENT_IN,
685 a2, type2, kind2, optional2, INTENT_IN,
686 a3, type3, kind3, optional3, INTENT_IN,
687 (void *) 0);
688 }
689
690
691 /* MINVAL, MAXVAL, PRODUCT, and SUM also get special treatment because
692 their argument also might have to be reordered. */
693
694 static void
695 add_sym_3red (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
696 int kind, int standard,
697 bool (*check) (gfc_actual_arglist *),
698 gfc_expr *(*simplify) (gfc_expr *, gfc_expr *, gfc_expr *),
699 void (*resolve) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *),
700 const char *a1, bt type1, int kind1, int optional1,
701 const char *a2, bt type2, int kind2, int optional2,
702 const char *a3, bt type3, int kind3, int optional3)
703 {
704 gfc_check_f cf;
705 gfc_simplify_f sf;
706 gfc_resolve_f rf;
707
708 cf.f3red = check;
709 sf.f3 = simplify;
710 rf.f3 = resolve;
711
712 add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf,
713 a1, type1, kind1, optional1, INTENT_IN,
714 a2, type2, kind2, optional2, INTENT_IN,
715 a3, type3, kind3, optional3, INTENT_IN,
716 (void *) 0);
717 }
718
719
720 /* Add a symbol to the subroutine list where the subroutine takes
721 3 arguments, specifying the intent of the arguments. */
722
723 static void
724 add_sym_3s (const char *name, gfc_isym_id id, enum klass cl, bt type,
725 int kind, int standard,
726 bool (*check) (gfc_expr *, gfc_expr *, gfc_expr *),
727 gfc_expr *(*simplify) (gfc_expr *, gfc_expr *, gfc_expr *),
728 void (*resolve) (gfc_code *),
729 const char *a1, bt type1, int kind1, int optional1,
730 sym_intent intent1, const char *a2, bt type2, int kind2,
731 int optional2, sym_intent intent2, const char *a3, bt type3,
732 int kind3, int optional3, sym_intent intent3)
733 {
734 gfc_check_f cf;
735 gfc_simplify_f sf;
736 gfc_resolve_f rf;
737
738 cf.f3 = check;
739 sf.f3 = simplify;
740 rf.s1 = resolve;
741
742 add_sym (name, id, cl, ACTUAL_NO, type, kind, standard, cf, sf, rf,
743 a1, type1, kind1, optional1, intent1,
744 a2, type2, kind2, optional2, intent2,
745 a3, type3, kind3, optional3, intent3,
746 (void *) 0);
747 }
748
749
750 /* Add a symbol to the function list where the function takes
751 4 arguments. */
752
753 static void
754 add_sym_4 (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type,
755 int kind, int standard,
756 bool (*check) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *),
757 gfc_expr *(*simplify) (gfc_expr *, gfc_expr *, gfc_expr *,
758 gfc_expr *),
759 void (*resolve) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *,
760 gfc_expr *),
761 const char *a1, bt type1, int kind1, int optional1,
762 const char *a2, bt type2, int kind2, int optional2,
763 const char *a3, bt type3, int kind3, int optional3,
764 const char *a4, bt type4, int kind4, int optional4 )
765 {
766 gfc_check_f cf;
767 gfc_simplify_f sf;
768 gfc_resolve_f rf;
769
770 cf.f4 = check;
771 sf.f4 = simplify;
772 rf.f4 = resolve;
773
774 add_sym (name, id, cl, actual_ok, type, kind, standard, cf, sf, rf,
775 a1, type1, kind1, optional1, INTENT_IN,
776 a2, type2, kind2, optional2, INTENT_IN,
777 a3, type3, kind3, optional3, INTENT_IN,
778 a4, type4, kind4, optional4, INTENT_IN,
779 (void *) 0);
780 }
781
782
783 /* Add a symbol to the subroutine list where the subroutine takes
784 4 arguments. */
785
786 static void
787 add_sym_4s (const char *name, gfc_isym_id id, enum klass cl, bt type, int kind,
788 int standard,
789 bool (*check) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *),
790 gfc_expr *(*simplify) (gfc_expr *, gfc_expr *, gfc_expr *,
791 gfc_expr *),
792 void (*resolve) (gfc_code *),
793 const char *a1, bt type1, int kind1, int optional1,
794 sym_intent intent1, const char *a2, bt type2, int kind2,
795 int optional2, sym_intent intent2, const char *a3, bt type3,
796 int kind3, int optional3, sym_intent intent3, const char *a4,
797 bt type4, int kind4, int optional4, sym_intent intent4)
798 {
799 gfc_check_f cf;
800 gfc_simplify_f sf;
801 gfc_resolve_f rf;
802
803 cf.f4 = check;
804 sf.f4 = simplify;
805 rf.s1 = resolve;
806
807 add_sym (name, id, cl, ACTUAL_NO, type, kind, standard, cf, sf, rf,
808 a1, type1, kind1, optional1, intent1,
809 a2, type2, kind2, optional2, intent2,
810 a3, type3, kind3, optional3, intent3,
811 a4, type4, kind4, optional4, intent4,
812 (void *) 0);
813 }
814
815
816 /* Add a symbol to the subroutine list where the subroutine takes
817 5 arguments. */
818
819 static void
820 add_sym_5s (const char *name, gfc_isym_id id, enum klass cl, bt type, int kind,
821 int standard,
822 bool (*check) (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *,
823 gfc_expr *),
824 gfc_expr *(*simplify) (gfc_expr *, gfc_expr *, gfc_expr *,
825 gfc_expr *, gfc_expr *),
826 void (*resolve) (gfc_code *),
827 const char *a1, bt type1, int kind1, int optional1,
828 sym_intent intent1, const char *a2, bt type2, int kind2,
829 int optional2, sym_intent intent2, const char *a3, bt type3,
830 int kind3, int optional3, sym_intent intent3, const char *a4,
831 bt type4, int kind4, int optional4, sym_intent intent4,
832 const char *a5, bt type5, int kind5, int optional5,
833 sym_intent intent5)
834 {
835 gfc_check_f cf;
836 gfc_simplify_f sf;
837 gfc_resolve_f rf;
838
839 cf.f5 = check;
840 sf.f5 = simplify;
841 rf.s1 = resolve;
842
843 add_sym (name, id, cl, ACTUAL_NO, type, kind, standard, cf, sf, rf,
844 a1, type1, kind1, optional1, intent1,
845 a2, type2, kind2, optional2, intent2,
846 a3, type3, kind3, optional3, intent3,
847 a4, type4, kind4, optional4, intent4,
848 a5, type5, kind5, optional5, intent5,
849 (void *) 0);
850 }
851
852
853 /* Locate an intrinsic symbol given a base pointer, number of elements
854 in the table and a pointer to a name. Returns the NULL pointer if
855 a name is not found. */
856
857 static gfc_intrinsic_sym *
858 find_sym (gfc_intrinsic_sym *start, int n, const char *name)
859 {
860 /* name may be a user-supplied string, so we must first make sure
861 that we're comparing against a pointer into the global string
862 table. */
863 const char *p = gfc_get_string (name);
864
865 while (n > 0)
866 {
867 if (p == start->name)
868 return start;
869
870 start++;
871 n--;
872 }
873
874 return NULL;
875 }
876
877
878 gfc_isym_id
879 gfc_isym_id_by_intmod (intmod_id from_intmod, int intmod_sym_id)
880 {
881 if (from_intmod == INTMOD_NONE)
882 return (gfc_isym_id) intmod_sym_id;
883 else if (from_intmod == INTMOD_ISO_C_BINDING)
884 return (gfc_isym_id) c_interop_kinds_table[intmod_sym_id].value;
885 else if (from_intmod == INTMOD_ISO_FORTRAN_ENV)
886 switch (intmod_sym_id)
887 {
888 #define NAMED_SUBROUTINE(a,b,c,d) \
889 case a: \
890 return (gfc_isym_id) c;
891 #define NAMED_FUNCTION(a,b,c,d) \
892 case a: \
893 return (gfc_isym_id) c;
894 #include "iso-fortran-env.def"
895 default:
896 gcc_unreachable ();
897 }
898 else
899 gcc_unreachable ();
900 return (gfc_isym_id) 0;
901 }
902
903
904 gfc_isym_id
905 gfc_isym_id_by_intmod_sym (gfc_symbol *sym)
906 {
907 return gfc_isym_id_by_intmod (sym->from_intmod, sym->intmod_sym_id);
908 }
909
910
911 gfc_intrinsic_sym *
912 gfc_intrinsic_subroutine_by_id (gfc_isym_id id)
913 {
914 gfc_intrinsic_sym *start = subroutines;
915 int n = nsub;
916
917 while (true)
918 {
919 gcc_assert (n > 0);
920 if (id == start->id)
921 return start;
922
923 start++;
924 n--;
925 }
926 }
927
928
929 gfc_intrinsic_sym *
930 gfc_intrinsic_function_by_id (gfc_isym_id id)
931 {
932 gfc_intrinsic_sym *start = functions;
933 int n = nfunc;
934
935 while (true)
936 {
937 gcc_assert (n > 0);
938 if (id == start->id)
939 return start;
940
941 start++;
942 n--;
943 }
944 }
945
946
947 /* Given a name, find a function in the intrinsic function table.
948 Returns NULL if not found. */
949
950 gfc_intrinsic_sym *
951 gfc_find_function (const char *name)
952 {
953 gfc_intrinsic_sym *sym;
954
955 sym = find_sym (functions, nfunc, name);
956 if (!sym || sym->from_module)
957 sym = find_sym (conversion, nconv, name);
958
959 return (!sym || sym->from_module) ? NULL : sym;
960 }
961
962
963 /* Given a name, find a function in the intrinsic subroutine table.
964 Returns NULL if not found. */
965
966 gfc_intrinsic_sym *
967 gfc_find_subroutine (const char *name)
968 {
969 gfc_intrinsic_sym *sym;
970 sym = find_sym (subroutines, nsub, name);
971 return (!sym || sym->from_module) ? NULL : sym;
972 }
973
974
975 /* Given a string, figure out if it is the name of a generic intrinsic
976 function or not. */
977
978 int
979 gfc_generic_intrinsic (const char *name)
980 {
981 gfc_intrinsic_sym *sym;
982
983 sym = gfc_find_function (name);
984 return (!sym || sym->from_module) ? 0 : sym->generic;
985 }
986
987
988 /* Given a string, figure out if it is the name of a specific
989 intrinsic function or not. */
990
991 int
992 gfc_specific_intrinsic (const char *name)
993 {
994 gfc_intrinsic_sym *sym;
995
996 sym = gfc_find_function (name);
997 return (!sym || sym->from_module) ? 0 : sym->specific;
998 }
999
1000
1001 /* Given a string, figure out if it is the name of an intrinsic function
1002 or subroutine allowed as an actual argument or not. */
1003 int
1004 gfc_intrinsic_actual_ok (const char *name, const bool subroutine_flag)
1005 {
1006 gfc_intrinsic_sym *sym;
1007
1008 /* Intrinsic subroutines are not allowed as actual arguments. */
1009 if (subroutine_flag)
1010 return 0;
1011 else
1012 {
1013 sym = gfc_find_function (name);
1014 return (sym == NULL) ? 0 : sym->actual_ok;
1015 }
1016 }
1017
1018
1019 /* Given a symbol, find out if it is (and is to be treated as) an intrinsic.
1020 If its name refers to an intrinsic, but this intrinsic is not included in
1021 the selected standard, this returns FALSE and sets the symbol's external
1022 attribute. */
1023
1024 bool
1025 gfc_is_intrinsic (gfc_symbol* sym, int subroutine_flag, locus loc)
1026 {
1027 gfc_intrinsic_sym* isym;
1028 const char* symstd;
1029
1030 /* If INTRINSIC attribute is already known, return. */
1031 if (sym->attr.intrinsic)
1032 return true;
1033
1034 /* Check for attributes which prevent the symbol from being INTRINSIC. */
1035 if (sym->attr.external || sym->attr.contained
1036 || sym->attr.if_source == IFSRC_IFBODY)
1037 return false;
1038
1039 if (subroutine_flag)
1040 isym = gfc_find_subroutine (sym->name);
1041 else
1042 isym = gfc_find_function (sym->name);
1043
1044 /* No such intrinsic available at all? */
1045 if (!isym)
1046 return false;
1047
1048 /* See if this intrinsic is allowed in the current standard. */
1049 if (!gfc_check_intrinsic_standard (isym, &symstd, false, loc)
1050 && !sym->attr.artificial)
1051 {
1052 if (sym->attr.proc == PROC_UNKNOWN
1053 && gfc_option.warn_intrinsics_std)
1054 gfc_warning_now ("The intrinsic '%s' at %L is not included in the"
1055 " selected standard but %s and '%s' will be"
1056 " treated as if declared EXTERNAL. Use an"
1057 " appropriate -std=* option or define"
1058 " -fall-intrinsics to allow this intrinsic.",
1059 sym->name, &loc, symstd, sym->name);
1060
1061 return false;
1062 }
1063
1064 return true;
1065 }
1066
1067
1068 /* Collect a set of intrinsic functions into a generic collection.
1069 The first argument is the name of the generic function, which is
1070 also the name of a specific function. The rest of the specifics
1071 currently in the table are placed into the list of specific
1072 functions associated with that generic.
1073
1074 PR fortran/32778
1075 FIXME: Remove the argument STANDARD if no regressions are
1076 encountered. Change all callers (approx. 360).
1077 */
1078
1079 static void
1080 make_generic (const char *name, gfc_isym_id id, int standard ATTRIBUTE_UNUSED)
1081 {
1082 gfc_intrinsic_sym *g;
1083
1084 if (sizing != SZ_NOTHING)
1085 return;
1086
1087 g = gfc_find_function (name);
1088 if (g == NULL)
1089 gfc_internal_error ("make_generic(): Can't find generic symbol '%s'",
1090 name);
1091
1092 gcc_assert (g->id == id);
1093
1094 g->generic = 1;
1095 g->specific = 1;
1096 if ((g + 1)->name != NULL)
1097 g->specific_head = g + 1;
1098 g++;
1099
1100 while (g->name != NULL)
1101 {
1102 g->next = g + 1;
1103 g->specific = 1;
1104 g++;
1105 }
1106
1107 g--;
1108 g->next = NULL;
1109 }
1110
1111
1112 /* Create a duplicate intrinsic function entry for the current
1113 function, the only differences being the alternate name and
1114 a different standard if necessary. Note that we use argument
1115 lists more than once, but all argument lists are freed as a
1116 single block. */
1117
1118 static void
1119 make_alias (const char *name, int standard)
1120 {
1121 switch (sizing)
1122 {
1123 case SZ_FUNCS:
1124 nfunc++;
1125 break;
1126
1127 case SZ_SUBS:
1128 nsub++;
1129 break;
1130
1131 case SZ_NOTHING:
1132 next_sym[0] = next_sym[-1];
1133 next_sym->name = gfc_get_string (name);
1134 next_sym->standard = standard;
1135 next_sym++;
1136 break;
1137
1138 default:
1139 break;
1140 }
1141 }
1142
1143
1144 /* Make the current subroutine noreturn. */
1145
1146 static void
1147 make_noreturn (void)
1148 {
1149 if (sizing == SZ_NOTHING)
1150 next_sym[-1].noreturn = 1;
1151 }
1152
1153
1154 /* Mark current intrinsic as module intrinsic. */
1155 static void
1156 make_from_module (void)
1157 {
1158 if (sizing == SZ_NOTHING)
1159 next_sym[-1].from_module = 1;
1160 }
1161
1162 /* Set the attr.value of the current procedure. */
1163
1164 static void
1165 set_attr_value (int n, ...)
1166 {
1167 gfc_intrinsic_arg *arg;
1168 va_list argp;
1169 int i;
1170
1171 if (sizing != SZ_NOTHING)
1172 return;
1173
1174 va_start (argp, n);
1175 arg = next_sym[-1].formal;
1176
1177 for (i = 0; i < n; i++)
1178 {
1179 gcc_assert (arg != NULL);
1180 arg->value = va_arg (argp, int);
1181 arg = arg->next;
1182 }
1183 va_end (argp);
1184 }
1185
1186
1187 /* Add intrinsic functions. */
1188
1189 static void
1190 add_functions (void)
1191 {
1192 /* Argument names as in the standard (to be used as argument keywords). */
1193 const char
1194 *a = "a", *f = "field", *pt = "pointer", *tg = "target",
1195 *b = "b", *m = "matrix", *ma = "matrix_a", *mb = "matrix_b",
1196 *c = "c", *n = "n", *ncopies= "ncopies", *pos = "pos", *bck = "back",
1197 *i = "i", *v = "vector", *va = "vector_a", *vb = "vector_b",
1198 *j = "j", *a1 = "a1", *fs = "fsource", *ts = "tsource",
1199 *l = "l", *a2 = "a2", *mo = "mold", *ord = "order",
1200 *p = "p", *ar = "array", *shp = "shape", *src = "source",
1201 *r = "r", *bd = "boundary", *pad = "pad", *set = "set",
1202 *s = "s", *dm = "dim", *kind = "kind", *msk = "mask",
1203 *x = "x", *sh = "shift", *stg = "string", *ssg = "substring",
1204 *y = "y", *sz = "size", *sta = "string_a", *stb = "string_b",
1205 *z = "z", *ln = "len", *ut = "unit", *han = "handler",
1206 *num = "number", *tm = "time", *nm = "name", *md = "mode",
1207 *vl = "values", *p1 = "path1", *p2 = "path2", *com = "command",
1208 *ca = "coarray", *sub = "sub";
1209
1210 int di, dr, dd, dl, dc, dz, ii;
1211
1212 di = gfc_default_integer_kind;
1213 dr = gfc_default_real_kind;
1214 dd = gfc_default_double_kind;
1215 dl = gfc_default_logical_kind;
1216 dc = gfc_default_character_kind;
1217 dz = gfc_default_complex_kind;
1218 ii = gfc_index_integer_kind;
1219
1220 add_sym_1 ("abs", GFC_ISYM_ABS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
1221 gfc_check_abs, gfc_simplify_abs, gfc_resolve_abs,
1222 a, BT_REAL, dr, REQUIRED);
1223
1224 add_sym_1 ("iabs", GFC_ISYM_ABS, CLASS_ELEMENTAL, ACTUAL_YES, BT_INTEGER, di, GFC_STD_F77,
1225 NULL, gfc_simplify_abs, gfc_resolve_abs,
1226 a, BT_INTEGER, di, REQUIRED);
1227
1228 add_sym_1 ("dabs", GFC_ISYM_ABS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
1229 gfc_check_fn_d, gfc_simplify_abs, gfc_resolve_abs,
1230 a, BT_REAL, dd, REQUIRED);
1231
1232 add_sym_1 ("cabs", GFC_ISYM_ABS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
1233 NULL, gfc_simplify_abs, gfc_resolve_abs,
1234 a, BT_COMPLEX, dz, REQUIRED);
1235
1236 add_sym_1 ("zabs", GFC_ISYM_ABS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_GNU,
1237 NULL, gfc_simplify_abs, gfc_resolve_abs,
1238 a, BT_COMPLEX, dd, REQUIRED);
1239
1240 make_alias ("cdabs", GFC_STD_GNU);
1241
1242 make_generic ("abs", GFC_ISYM_ABS, GFC_STD_F77);
1243
1244 /* The checking function for ACCESS is called gfc_check_access_func
1245 because the name gfc_check_access is already used in module.c. */
1246 add_sym_2 ("access", GFC_ISYM_ACCESS, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
1247 di, GFC_STD_GNU, gfc_check_access_func, NULL, gfc_resolve_access,
1248 nm, BT_CHARACTER, dc, REQUIRED, md, BT_CHARACTER, dc, REQUIRED);
1249
1250 make_generic ("access", GFC_ISYM_ACCESS, GFC_STD_GNU);
1251
1252 add_sym_2 ("achar", GFC_ISYM_ACHAR, CLASS_ELEMENTAL, ACTUAL_NO,
1253 BT_CHARACTER, dc, GFC_STD_F95,
1254 gfc_check_achar, gfc_simplify_achar, gfc_resolve_achar,
1255 i, BT_INTEGER, di, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
1256
1257 make_generic ("achar", GFC_ISYM_ACHAR, GFC_STD_F95);
1258
1259 add_sym_1 ("acos", GFC_ISYM_ACOS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
1260 gfc_check_fn_rc2008, gfc_simplify_acos, gfc_resolve_acos,
1261 x, BT_REAL, dr, REQUIRED);
1262
1263 add_sym_1 ("dacos", GFC_ISYM_ACOS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
1264 gfc_check_fn_d, gfc_simplify_acos, gfc_resolve_acos,
1265 x, BT_REAL, dd, REQUIRED);
1266
1267 make_generic ("acos", GFC_ISYM_ACOS, GFC_STD_F77);
1268
1269 add_sym_1 ("acosh", GFC_ISYM_ACOSH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr,
1270 GFC_STD_F2008, gfc_check_fn_rc2008, gfc_simplify_acosh,
1271 gfc_resolve_acosh, x, BT_REAL, dr, REQUIRED);
1272
1273 add_sym_1 ("dacosh", GFC_ISYM_ACOSH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_GNU,
1274 gfc_check_fn_d, gfc_simplify_acosh, gfc_resolve_acosh,
1275 x, BT_REAL, dd, REQUIRED);
1276
1277 make_generic ("acosh", GFC_ISYM_ACOSH, GFC_STD_F2008);
1278
1279 add_sym_1 ("adjustl", GFC_ISYM_ADJUSTL, CLASS_ELEMENTAL, ACTUAL_NO,
1280 BT_CHARACTER, dc, GFC_STD_F95, NULL, gfc_simplify_adjustl,
1281 gfc_resolve_adjustl, stg, BT_CHARACTER, 0, REQUIRED);
1282
1283 make_generic ("adjustl", GFC_ISYM_ADJUSTL, GFC_STD_F95);
1284
1285 add_sym_1 ("adjustr", GFC_ISYM_ADJUSTR, CLASS_ELEMENTAL, ACTUAL_NO,
1286 BT_CHARACTER, dc, GFC_STD_F95, NULL, gfc_simplify_adjustr,
1287 gfc_resolve_adjustr, stg, BT_CHARACTER, 0, REQUIRED);
1288
1289 make_generic ("adjustr", GFC_ISYM_ADJUSTR, GFC_STD_F95);
1290
1291 add_sym_1 ("aimag", GFC_ISYM_AIMAG, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
1292 gfc_check_fn_c, gfc_simplify_aimag, gfc_resolve_aimag,
1293 z, BT_COMPLEX, dz, REQUIRED);
1294
1295 make_alias ("imag", GFC_STD_GNU);
1296 make_alias ("imagpart", GFC_STD_GNU);
1297
1298 add_sym_1 ("dimag", GFC_ISYM_AIMAG, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_GNU,
1299 NULL, gfc_simplify_aimag, gfc_resolve_aimag,
1300 z, BT_COMPLEX, dd, REQUIRED);
1301
1302 make_generic ("aimag", GFC_ISYM_AIMAG, GFC_STD_F77);
1303
1304 add_sym_2 ("aint", GFC_ISYM_AINT, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
1305 gfc_check_a_xkind, gfc_simplify_aint, gfc_resolve_aint,
1306 a, BT_REAL, dr, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
1307
1308 add_sym_1 ("dint", GFC_ISYM_AINT, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
1309 NULL, gfc_simplify_dint, gfc_resolve_dint,
1310 a, BT_REAL, dd, REQUIRED);
1311
1312 make_generic ("aint", GFC_ISYM_AINT, GFC_STD_F77);
1313
1314 add_sym_2 ("all", GFC_ISYM_ALL, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F95,
1315 gfc_check_all_any, gfc_simplify_all, gfc_resolve_all,
1316 msk, BT_LOGICAL, dl, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL);
1317
1318 make_generic ("all", GFC_ISYM_ALL, GFC_STD_F95);
1319
1320 add_sym_1 ("allocated", GFC_ISYM_ALLOCATED, CLASS_INQUIRY, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F95,
1321 gfc_check_allocated, NULL, NULL,
1322 ar, BT_UNKNOWN, 0, REQUIRED);
1323
1324 make_generic ("allocated", GFC_ISYM_ALLOCATED, GFC_STD_F95);
1325
1326 add_sym_2 ("anint", GFC_ISYM_ANINT, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
1327 gfc_check_a_xkind, gfc_simplify_anint, gfc_resolve_anint,
1328 a, BT_REAL, dr, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
1329
1330 add_sym_1 ("dnint", GFC_ISYM_ANINT, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
1331 NULL, gfc_simplify_dnint, gfc_resolve_dnint,
1332 a, BT_REAL, dd, REQUIRED);
1333
1334 make_generic ("anint", GFC_ISYM_ANINT, GFC_STD_F77);
1335
1336 add_sym_2 ("any", GFC_ISYM_ANY, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F95,
1337 gfc_check_all_any, gfc_simplify_any, gfc_resolve_any,
1338 msk, BT_LOGICAL, dl, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL);
1339
1340 make_generic ("any", GFC_ISYM_ANY, GFC_STD_F95);
1341
1342 add_sym_1 ("asin", GFC_ISYM_ASIN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
1343 gfc_check_fn_rc2008, gfc_simplify_asin, gfc_resolve_asin,
1344 x, BT_REAL, dr, REQUIRED);
1345
1346 add_sym_1 ("dasin", GFC_ISYM_ASIN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
1347 gfc_check_fn_d, gfc_simplify_asin, gfc_resolve_asin,
1348 x, BT_REAL, dd, REQUIRED);
1349
1350 make_generic ("asin", GFC_ISYM_ASIN, GFC_STD_F77);
1351
1352 add_sym_1 ("asinh", GFC_ISYM_ASINH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr,
1353 GFC_STD_F2008, gfc_check_fn_rc2008, gfc_simplify_asinh,
1354 gfc_resolve_asinh, x, BT_REAL, dr, REQUIRED);
1355
1356 add_sym_1 ("dasinh", GFC_ISYM_ASINH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_GNU,
1357 gfc_check_fn_d, gfc_simplify_asinh, gfc_resolve_asinh,
1358 x, BT_REAL, dd, REQUIRED);
1359
1360 make_generic ("asinh", GFC_ISYM_ASINH, GFC_STD_F2008);
1361
1362 add_sym_2 ("associated", GFC_ISYM_ASSOCIATED, CLASS_INQUIRY, ACTUAL_NO, BT_LOGICAL, dl,
1363 GFC_STD_F95, gfc_check_associated, NULL, NULL,
1364 pt, BT_UNKNOWN, 0, REQUIRED, tg, BT_UNKNOWN, 0, OPTIONAL);
1365
1366 make_generic ("associated", GFC_ISYM_ASSOCIATED, GFC_STD_F95);
1367
1368 add_sym_1 ("atan", GFC_ISYM_ATAN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
1369 gfc_check_fn_rc2008, gfc_simplify_atan, gfc_resolve_atan,
1370 x, BT_REAL, dr, REQUIRED);
1371
1372 add_sym_1 ("datan", GFC_ISYM_ATAN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
1373 gfc_check_fn_d, gfc_simplify_atan, gfc_resolve_atan,
1374 x, BT_REAL, dd, REQUIRED);
1375
1376 /* Two-argument version of atan, equivalent to atan2. */
1377 add_sym_2 ("atan", GFC_ISYM_ATAN2, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F2008,
1378 gfc_check_atan_2, gfc_simplify_atan2, gfc_resolve_atan2,
1379 y, BT_REAL, dr, REQUIRED, x, BT_REAL, dr, REQUIRED);
1380
1381 make_generic ("atan", GFC_ISYM_ATAN, GFC_STD_F77);
1382
1383 add_sym_1 ("atanh", GFC_ISYM_ATANH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr,
1384 GFC_STD_F2008, gfc_check_fn_rc2008, gfc_simplify_atanh,
1385 gfc_resolve_atanh, x, BT_REAL, dr, REQUIRED);
1386
1387 add_sym_1 ("datanh", GFC_ISYM_ATANH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_GNU,
1388 gfc_check_fn_d, gfc_simplify_atanh, gfc_resolve_atanh,
1389 x, BT_REAL, dd, REQUIRED);
1390
1391 make_generic ("atanh", GFC_ISYM_ATANH, GFC_STD_F2008);
1392
1393 add_sym_2 ("atan2", GFC_ISYM_ATAN2, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
1394 gfc_check_atan2, gfc_simplify_atan2, gfc_resolve_atan2,
1395 y, BT_REAL, dr, REQUIRED, x, BT_REAL, dr, REQUIRED);
1396
1397 add_sym_2 ("datan2", GFC_ISYM_ATAN2, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
1398 gfc_check_datan2, gfc_simplify_atan2, gfc_resolve_atan2,
1399 y, BT_REAL, dd, REQUIRED, x, BT_REAL, dd, REQUIRED);
1400
1401 make_generic ("atan2", GFC_ISYM_ATAN2, GFC_STD_F77);
1402
1403 /* Bessel and Neumann functions for G77 compatibility. */
1404 add_sym_1 ("besj0", GFC_ISYM_J0, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
1405 gfc_check_fn_r, gfc_simplify_bessel_j0, gfc_resolve_g77_math1,
1406 x, BT_REAL, dr, REQUIRED);
1407
1408 make_alias ("bessel_j0", GFC_STD_F2008);
1409
1410 add_sym_1 ("dbesj0", GFC_ISYM_J0, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_GNU,
1411 gfc_check_fn_d, gfc_simplify_bessel_j0, gfc_resolve_g77_math1,
1412 x, BT_REAL, dd, REQUIRED);
1413
1414 make_generic ("bessel_j0", GFC_ISYM_J0, GFC_STD_F2008);
1415
1416 add_sym_1 ("besj1", GFC_ISYM_J1, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
1417 gfc_check_fn_r, gfc_simplify_bessel_j1, gfc_resolve_g77_math1,
1418 x, BT_REAL, dr, REQUIRED);
1419
1420 make_alias ("bessel_j1", GFC_STD_F2008);
1421
1422 add_sym_1 ("dbesj1", GFC_ISYM_J1, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_GNU,
1423 gfc_check_fn_d, gfc_simplify_bessel_j1, gfc_resolve_g77_math1,
1424 x, BT_REAL, dd, REQUIRED);
1425
1426 make_generic ("bessel_j1", GFC_ISYM_J1, GFC_STD_F2008);
1427
1428 add_sym_2 ("besjn", GFC_ISYM_JN, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
1429 gfc_check_besn, gfc_simplify_bessel_jn, gfc_resolve_besn,
1430 n, BT_INTEGER, di, REQUIRED, x, BT_REAL, dr, REQUIRED);
1431
1432 make_alias ("bessel_jn", GFC_STD_F2008);
1433
1434 add_sym_2 ("dbesjn", GFC_ISYM_JN, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_GNU,
1435 gfc_check_besn, gfc_simplify_bessel_jn, gfc_resolve_besn,
1436 n, BT_INTEGER, di, REQUIRED, x, BT_REAL, dd, REQUIRED);
1437
1438 add_sym_3 ("bessel_jn", GFC_ISYM_JN2, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F2008,
1439 gfc_check_bessel_n2, gfc_simplify_bessel_jn2, gfc_resolve_bessel_n2,
1440 "n1", BT_INTEGER, di, REQUIRED,"n2", BT_INTEGER, di, REQUIRED,
1441 x, BT_REAL, dr, REQUIRED);
1442 set_attr_value (3, true, true, true);
1443
1444 make_generic ("bessel_jn", GFC_ISYM_JN, GFC_STD_F2008);
1445
1446 add_sym_1 ("besy0", GFC_ISYM_Y0, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
1447 gfc_check_fn_r, gfc_simplify_bessel_y0, gfc_resolve_g77_math1,
1448 x, BT_REAL, dr, REQUIRED);
1449
1450 make_alias ("bessel_y0", GFC_STD_F2008);
1451
1452 add_sym_1 ("dbesy0", GFC_ISYM_Y0, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_GNU,
1453 gfc_check_fn_d, gfc_simplify_bessel_y0, gfc_resolve_g77_math1,
1454 x, BT_REAL, dd, REQUIRED);
1455
1456 make_generic ("bessel_y0", GFC_ISYM_Y0, GFC_STD_F2008);
1457
1458 add_sym_1 ("besy1", GFC_ISYM_Y1, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
1459 gfc_check_fn_r, gfc_simplify_bessel_y1, gfc_resolve_g77_math1,
1460 x, BT_REAL, dr, REQUIRED);
1461
1462 make_alias ("bessel_y1", GFC_STD_F2008);
1463
1464 add_sym_1 ("dbesy1", GFC_ISYM_Y1, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_GNU,
1465 gfc_check_fn_d, gfc_simplify_bessel_y1, gfc_resolve_g77_math1,
1466 x, BT_REAL, dd, REQUIRED);
1467
1468 make_generic ("bessel_y1", GFC_ISYM_Y1, GFC_STD_F2008);
1469
1470 add_sym_2 ("besyn", GFC_ISYM_YN, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
1471 gfc_check_besn, gfc_simplify_bessel_yn, gfc_resolve_besn,
1472 n, BT_INTEGER, di, REQUIRED, x, BT_REAL, dr, REQUIRED);
1473
1474 make_alias ("bessel_yn", GFC_STD_F2008);
1475
1476 add_sym_2 ("dbesyn", GFC_ISYM_YN, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_GNU,
1477 gfc_check_besn, gfc_simplify_bessel_yn, gfc_resolve_besn,
1478 n, BT_INTEGER, di, REQUIRED, x, BT_REAL, dd, REQUIRED);
1479
1480 add_sym_3 ("bessel_yn", GFC_ISYM_YN2, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F2008,
1481 gfc_check_bessel_n2, gfc_simplify_bessel_yn2, gfc_resolve_bessel_n2,
1482 "n1", BT_INTEGER, di, REQUIRED,"n2", BT_INTEGER, di, REQUIRED,
1483 x, BT_REAL, dr, REQUIRED);
1484 set_attr_value (3, true, true, true);
1485
1486 make_generic ("bessel_yn", GFC_ISYM_YN, GFC_STD_F2008);
1487
1488 add_sym_2 ("bge", GFC_ISYM_BGE, CLASS_ELEMENTAL, ACTUAL_NO,
1489 BT_LOGICAL, dl, GFC_STD_F2008,
1490 gfc_check_bge_bgt_ble_blt, gfc_simplify_bge, NULL,
1491 i, BT_INTEGER, di, REQUIRED, j, BT_INTEGER, di, REQUIRED);
1492
1493 make_generic ("bge", GFC_ISYM_BGE, GFC_STD_F2008);
1494
1495 add_sym_2 ("bgt", GFC_ISYM_BGT, CLASS_ELEMENTAL, ACTUAL_NO,
1496 BT_LOGICAL, dl, GFC_STD_F2008,
1497 gfc_check_bge_bgt_ble_blt, gfc_simplify_bgt, NULL,
1498 i, BT_INTEGER, di, REQUIRED, j, BT_INTEGER, di, REQUIRED);
1499
1500 make_generic ("bgt", GFC_ISYM_BGT, GFC_STD_F2008);
1501
1502 add_sym_1 ("bit_size", GFC_ISYM_BIT_SIZE, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
1503 gfc_check_i, gfc_simplify_bit_size, NULL,
1504 i, BT_INTEGER, di, REQUIRED);
1505
1506 make_generic ("bit_size", GFC_ISYM_BIT_SIZE, GFC_STD_F95);
1507
1508 add_sym_2 ("ble", GFC_ISYM_BLE, CLASS_ELEMENTAL, ACTUAL_NO,
1509 BT_LOGICAL, dl, GFC_STD_F2008,
1510 gfc_check_bge_bgt_ble_blt, gfc_simplify_ble, NULL,
1511 i, BT_INTEGER, di, REQUIRED, j, BT_INTEGER, di, REQUIRED);
1512
1513 make_generic ("ble", GFC_ISYM_BLE, GFC_STD_F2008);
1514
1515 add_sym_2 ("blt", GFC_ISYM_BLT, CLASS_ELEMENTAL, ACTUAL_NO,
1516 BT_LOGICAL, dl, GFC_STD_F2008,
1517 gfc_check_bge_bgt_ble_blt, gfc_simplify_blt, NULL,
1518 i, BT_INTEGER, di, REQUIRED, j, BT_INTEGER, di, REQUIRED);
1519
1520 make_generic ("blt", GFC_ISYM_BLT, GFC_STD_F2008);
1521
1522 add_sym_2 ("btest", GFC_ISYM_BTEST, CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F95,
1523 gfc_check_bitfcn, gfc_simplify_btest, gfc_resolve_btest,
1524 i, BT_INTEGER, di, REQUIRED, pos, BT_INTEGER, di, REQUIRED);
1525
1526 make_generic ("btest", GFC_ISYM_BTEST, GFC_STD_F95);
1527
1528 add_sym_2 ("ceiling", GFC_ISYM_CEILING, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
1529 gfc_check_a_ikind, gfc_simplify_ceiling, gfc_resolve_ceiling,
1530 a, BT_REAL, dr, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
1531
1532 make_generic ("ceiling", GFC_ISYM_CEILING, GFC_STD_F95);
1533
1534 add_sym_2 ("char", GFC_ISYM_CHAR, CLASS_ELEMENTAL, ACTUAL_NO, BT_CHARACTER, dc, GFC_STD_F77,
1535 gfc_check_char, gfc_simplify_char, gfc_resolve_char,
1536 i, BT_INTEGER, di, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
1537
1538 make_generic ("char", GFC_ISYM_CHAR, GFC_STD_F77);
1539
1540 add_sym_1 ("chdir", GFC_ISYM_CHDIR, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, di,
1541 GFC_STD_GNU, gfc_check_chdir, NULL, gfc_resolve_chdir,
1542 nm, BT_CHARACTER, dc, REQUIRED);
1543
1544 make_generic ("chdir", GFC_ISYM_CHDIR, GFC_STD_GNU);
1545
1546 add_sym_2 ("chmod", GFC_ISYM_CHMOD, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
1547 di, GFC_STD_GNU, gfc_check_chmod, NULL, gfc_resolve_chmod,
1548 nm, BT_CHARACTER, dc, REQUIRED, md, BT_CHARACTER, dc, REQUIRED);
1549
1550 make_generic ("chmod", GFC_ISYM_CHMOD, GFC_STD_GNU);
1551
1552 add_sym_3 ("cmplx", GFC_ISYM_CMPLX, CLASS_ELEMENTAL, ACTUAL_NO, BT_COMPLEX, dz, GFC_STD_F77,
1553 gfc_check_cmplx, gfc_simplify_cmplx, gfc_resolve_cmplx,
1554 x, BT_UNKNOWN, dr, REQUIRED, y, BT_UNKNOWN, dr, OPTIONAL,
1555 kind, BT_INTEGER, di, OPTIONAL);
1556
1557 make_generic ("cmplx", GFC_ISYM_CMPLX, GFC_STD_F77);
1558
1559 add_sym_0 ("command_argument_count", GFC_ISYM_COMMAND_ARGUMENT_COUNT, CLASS_INQUIRY,
1560 ACTUAL_NO, BT_INTEGER, di, GFC_STD_F2003, NULL, NULL, NULL);
1561
1562 make_generic ("command_argument_count", GFC_ISYM_COMMAND_ARGUMENT_COUNT,
1563 GFC_STD_F2003);
1564
1565 add_sym_2 ("complex", GFC_ISYM_COMPLEX, CLASS_ELEMENTAL, ACTUAL_NO, BT_COMPLEX, dz, GFC_STD_GNU,
1566 gfc_check_complex, gfc_simplify_complex, gfc_resolve_complex,
1567 x, BT_UNKNOWN, dr, REQUIRED, y, BT_UNKNOWN, dr, REQUIRED);
1568
1569 make_generic ("complex", GFC_ISYM_COMPLEX, GFC_STD_GNU);
1570
1571 /* Making dcmplx a specific of cmplx causes cmplx to return a double
1572 complex instead of the default complex. */
1573
1574 add_sym_2 ("dcmplx", GFC_ISYM_CMPLX, CLASS_ELEMENTAL, ACTUAL_NO, BT_COMPLEX, dd, GFC_STD_GNU,
1575 gfc_check_dcmplx, gfc_simplify_dcmplx, gfc_resolve_dcmplx,
1576 x, BT_REAL, dd, REQUIRED, y, BT_REAL, dd, OPTIONAL);
1577
1578 make_generic ("dcmplx", GFC_ISYM_CMPLX, GFC_STD_GNU);
1579
1580 add_sym_1 ("conjg", GFC_ISYM_CONJG, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dz, GFC_STD_F77,
1581 gfc_check_fn_c, gfc_simplify_conjg, gfc_resolve_conjg,
1582 z, BT_COMPLEX, dz, REQUIRED);
1583
1584 add_sym_1 ("dconjg", GFC_ISYM_CONJG, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dd, GFC_STD_GNU,
1585 NULL, gfc_simplify_conjg, gfc_resolve_conjg,
1586 z, BT_COMPLEX, dd, REQUIRED);
1587
1588 make_generic ("conjg", GFC_ISYM_CONJG, GFC_STD_F77);
1589
1590 add_sym_1 ("cos", GFC_ISYM_COS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
1591 gfc_check_fn_rc, gfc_simplify_cos, gfc_resolve_cos,
1592 x, BT_REAL, dr, REQUIRED);
1593
1594 add_sym_1 ("dcos", GFC_ISYM_COS, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
1595 gfc_check_fn_d, gfc_simplify_cos, gfc_resolve_cos,
1596 x, BT_REAL, dd, REQUIRED);
1597
1598 add_sym_1 ("ccos", GFC_ISYM_COS, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dz, GFC_STD_F77,
1599 NULL, gfc_simplify_cos, gfc_resolve_cos,
1600 x, BT_COMPLEX, dz, REQUIRED);
1601
1602 add_sym_1 ("zcos", GFC_ISYM_COS, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dd, GFC_STD_GNU,
1603 NULL, gfc_simplify_cos, gfc_resolve_cos,
1604 x, BT_COMPLEX, dd, REQUIRED);
1605
1606 make_alias ("cdcos", GFC_STD_GNU);
1607
1608 make_generic ("cos", GFC_ISYM_COS, GFC_STD_F77);
1609
1610 add_sym_1 ("cosh", GFC_ISYM_COSH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
1611 gfc_check_fn_rc2008, gfc_simplify_cosh, gfc_resolve_cosh,
1612 x, BT_REAL, dr, REQUIRED);
1613
1614 add_sym_1 ("dcosh", GFC_ISYM_COSH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
1615 gfc_check_fn_d, gfc_simplify_cosh, gfc_resolve_cosh,
1616 x, BT_REAL, dd, REQUIRED);
1617
1618 make_generic ("cosh", GFC_ISYM_COSH, GFC_STD_F77);
1619
1620 add_sym_3 ("count", GFC_ISYM_COUNT, CLASS_TRANSFORMATIONAL, ACTUAL_NO,
1621 BT_INTEGER, di, GFC_STD_F95,
1622 gfc_check_count, gfc_simplify_count, gfc_resolve_count,
1623 msk, BT_LOGICAL, dl, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
1624 kind, BT_INTEGER, di, OPTIONAL);
1625
1626 make_generic ("count", GFC_ISYM_COUNT, GFC_STD_F95);
1627
1628 add_sym_3 ("cshift", GFC_ISYM_CSHIFT, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
1629 gfc_check_cshift, NULL, gfc_resolve_cshift,
1630 ar, BT_REAL, dr, REQUIRED, sh, BT_INTEGER, di, REQUIRED,
1631 dm, BT_INTEGER, ii, OPTIONAL);
1632
1633 make_generic ("cshift", GFC_ISYM_CSHIFT, GFC_STD_F95);
1634
1635 add_sym_1 ("ctime", GFC_ISYM_CTIME, CLASS_IMPURE, ACTUAL_NO, BT_CHARACTER,
1636 0, GFC_STD_GNU, gfc_check_ctime, NULL, gfc_resolve_ctime,
1637 tm, BT_INTEGER, di, REQUIRED);
1638
1639 make_generic ("ctime", GFC_ISYM_CTIME, GFC_STD_GNU);
1640
1641 add_sym_1 ("dble", GFC_ISYM_DBLE, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_F77,
1642 gfc_check_dble, gfc_simplify_dble, gfc_resolve_dble,
1643 a, BT_REAL, dr, REQUIRED);
1644
1645 make_generic ("dble", GFC_ISYM_DBLE, GFC_STD_F77);
1646
1647 add_sym_1 ("digits", GFC_ISYM_DIGITS, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
1648 gfc_check_digits, gfc_simplify_digits, NULL,
1649 x, BT_UNKNOWN, dr, REQUIRED);
1650
1651 make_generic ("digits", GFC_ISYM_DIGITS, GFC_STD_F95);
1652
1653 add_sym_2 ("dim", GFC_ISYM_DIM, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
1654 gfc_check_a_p, gfc_simplify_dim, gfc_resolve_dim,
1655 x, BT_REAL, dr, REQUIRED, y, BT_REAL, dr, REQUIRED);
1656
1657 add_sym_2 ("idim", GFC_ISYM_DIM, CLASS_ELEMENTAL, ACTUAL_YES, BT_INTEGER, di, GFC_STD_F77,
1658 NULL, gfc_simplify_dim, gfc_resolve_dim,
1659 x, BT_INTEGER, di, REQUIRED, y, BT_INTEGER, di, REQUIRED);
1660
1661 add_sym_2 ("ddim", GFC_ISYM_DIM, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
1662 gfc_check_x_yd, gfc_simplify_dim, gfc_resolve_dim,
1663 x, BT_REAL, dd, REQUIRED, y, BT_REAL, dd, REQUIRED);
1664
1665 make_generic ("dim", GFC_ISYM_DIM, GFC_STD_F77);
1666
1667 add_sym_2 ("dot_product", GFC_ISYM_DOT_PRODUCT, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr,
1668 GFC_STD_F95, gfc_check_dot_product, gfc_simplify_dot_product, gfc_resolve_dot_product,
1669 va, BT_REAL, dr, REQUIRED, vb, BT_REAL, dr, REQUIRED);
1670
1671 make_generic ("dot_product", GFC_ISYM_DOT_PRODUCT, GFC_STD_F95);
1672
1673 add_sym_2 ("dprod", GFC_ISYM_DPROD,CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
1674 gfc_check_dprod, gfc_simplify_dprod, gfc_resolve_dprod,
1675 x, BT_REAL, dr, REQUIRED, y, BT_REAL, dr, REQUIRED);
1676
1677 make_generic ("dprod", GFC_ISYM_DPROD, GFC_STD_F77);
1678
1679 add_sym_1 ("dreal", GFC_ISYM_REAL, CLASS_ELEMENTAL, ACTUAL_NO,
1680 BT_REAL, dd, GFC_STD_GNU, NULL, gfc_simplify_dreal, NULL,
1681 a, BT_COMPLEX, dd, REQUIRED);
1682
1683 make_generic ("dreal", GFC_ISYM_REAL, GFC_STD_GNU);
1684
1685 add_sym_3 ("dshiftl", GFC_ISYM_DSHIFTL, CLASS_ELEMENTAL, ACTUAL_NO,
1686 BT_INTEGER, di, GFC_STD_F2008,
1687 gfc_check_dshift, gfc_simplify_dshiftl, gfc_resolve_dshift,
1688 i, BT_INTEGER, di, REQUIRED,
1689 j, BT_INTEGER, di, REQUIRED,
1690 sh, BT_INTEGER, di, REQUIRED);
1691
1692 make_generic ("dshiftl", GFC_ISYM_DSHIFTL, GFC_STD_F2008);
1693
1694 add_sym_3 ("dshiftr", GFC_ISYM_DSHIFTR, CLASS_ELEMENTAL, ACTUAL_NO,
1695 BT_INTEGER, di, GFC_STD_F2008,
1696 gfc_check_dshift, gfc_simplify_dshiftr, gfc_resolve_dshift,
1697 i, BT_INTEGER, di, REQUIRED,
1698 j, BT_INTEGER, di, REQUIRED,
1699 sh, BT_INTEGER, di, REQUIRED);
1700
1701 make_generic ("dshiftr", GFC_ISYM_DSHIFTR, GFC_STD_F2008);
1702
1703 add_sym_4 ("eoshift", GFC_ISYM_EOSHIFT, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
1704 gfc_check_eoshift, NULL, gfc_resolve_eoshift,
1705 ar, BT_REAL, dr, REQUIRED, sh, BT_INTEGER, ii, REQUIRED,
1706 bd, BT_REAL, dr, OPTIONAL, dm, BT_INTEGER, ii, OPTIONAL);
1707
1708 make_generic ("eoshift", GFC_ISYM_EOSHIFT, GFC_STD_F95);
1709
1710 add_sym_1 ("epsilon", GFC_ISYM_EPSILON, CLASS_INQUIRY, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
1711 gfc_check_x, gfc_simplify_epsilon, NULL,
1712 x, BT_REAL, dr, REQUIRED);
1713
1714 make_generic ("epsilon", GFC_ISYM_EPSILON, GFC_STD_F95);
1715
1716 /* G77 compatibility for the ERF() and ERFC() functions. */
1717 add_sym_1 ("erf", GFC_ISYM_ERF, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr,
1718 GFC_STD_F2008, gfc_check_fn_r, gfc_simplify_erf,
1719 gfc_resolve_g77_math1, x, BT_REAL, dr, REQUIRED);
1720
1721 add_sym_1 ("derf", GFC_ISYM_ERF, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd,
1722 GFC_STD_GNU, gfc_check_fn_d, gfc_simplify_erf,
1723 gfc_resolve_g77_math1, x, BT_REAL, dd, REQUIRED);
1724
1725 make_generic ("erf", GFC_ISYM_ERF, GFC_STD_F2008);
1726
1727 add_sym_1 ("erfc", GFC_ISYM_ERFC, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr,
1728 GFC_STD_F2008, gfc_check_fn_r, gfc_simplify_erfc,
1729 gfc_resolve_g77_math1, x, BT_REAL, dr, REQUIRED);
1730
1731 add_sym_1 ("derfc", GFC_ISYM_ERFC, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd,
1732 GFC_STD_GNU, gfc_check_fn_d, gfc_simplify_erfc,
1733 gfc_resolve_g77_math1, x, BT_REAL, dd, REQUIRED);
1734
1735 make_generic ("erfc", GFC_ISYM_ERFC, GFC_STD_F2008);
1736
1737 add_sym_1 ("erfc_scaled", GFC_ISYM_ERFC_SCALED, CLASS_ELEMENTAL, ACTUAL_NO,
1738 BT_REAL, dr, GFC_STD_F2008, gfc_check_fn_r,
1739 gfc_simplify_erfc_scaled, gfc_resolve_g77_math1, x, BT_REAL,
1740 dr, REQUIRED);
1741
1742 make_generic ("erfc_scaled", GFC_ISYM_ERFC_SCALED, GFC_STD_F2008);
1743
1744 /* G77 compatibility */
1745 add_sym_1 ("dtime", GFC_ISYM_DTIME, CLASS_IMPURE, ACTUAL_NO, BT_REAL,
1746 4, GFC_STD_GNU, gfc_check_dtime_etime, NULL, NULL,
1747 x, BT_REAL, 4, REQUIRED);
1748
1749 make_generic ("dtime", GFC_ISYM_DTIME, GFC_STD_GNU);
1750
1751 add_sym_1 ("etime", GFC_ISYM_ETIME, CLASS_IMPURE, ACTUAL_NO, BT_REAL,
1752 4, GFC_STD_GNU, gfc_check_dtime_etime, NULL, NULL,
1753 x, BT_REAL, 4, REQUIRED);
1754
1755 make_generic ("etime", GFC_ISYM_ETIME, GFC_STD_GNU);
1756
1757 add_sym_1 ("exp", GFC_ISYM_EXP, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
1758 gfc_check_fn_rc, gfc_simplify_exp, gfc_resolve_exp,
1759 x, BT_REAL, dr, REQUIRED);
1760
1761 add_sym_1 ("dexp", GFC_ISYM_EXP, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
1762 gfc_check_fn_d, gfc_simplify_exp, gfc_resolve_exp,
1763 x, BT_REAL, dd, REQUIRED);
1764
1765 add_sym_1 ("cexp", GFC_ISYM_EXP, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dz, GFC_STD_F77,
1766 NULL, gfc_simplify_exp, gfc_resolve_exp,
1767 x, BT_COMPLEX, dz, REQUIRED);
1768
1769 add_sym_1 ("zexp", GFC_ISYM_EXP, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dd, GFC_STD_GNU,
1770 NULL, gfc_simplify_exp, gfc_resolve_exp,
1771 x, BT_COMPLEX, dd, REQUIRED);
1772
1773 make_alias ("cdexp", GFC_STD_GNU);
1774
1775 make_generic ("exp", GFC_ISYM_EXP, GFC_STD_F77);
1776
1777 add_sym_1 ("exponent", GFC_ISYM_EXPONENT, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
1778 gfc_check_x, gfc_simplify_exponent, gfc_resolve_exponent,
1779 x, BT_REAL, dr, REQUIRED);
1780
1781 make_generic ("exponent", GFC_ISYM_EXPONENT, GFC_STD_F95);
1782
1783 add_sym_2 ("extends_type_of", GFC_ISYM_EXTENDS_TYPE_OF, CLASS_INQUIRY,
1784 ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F2003,
1785 gfc_check_same_type_as, gfc_simplify_extends_type_of,
1786 gfc_resolve_extends_type_of,
1787 a, BT_UNKNOWN, 0, REQUIRED,
1788 mo, BT_UNKNOWN, 0, REQUIRED);
1789
1790 add_sym_0 ("fdate", GFC_ISYM_FDATE, CLASS_IMPURE, ACTUAL_NO, BT_CHARACTER,
1791 dc, GFC_STD_GNU, NULL, NULL, gfc_resolve_fdate);
1792
1793 make_generic ("fdate", GFC_ISYM_FDATE, GFC_STD_GNU);
1794
1795 add_sym_2 ("floor", GFC_ISYM_FLOOR, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
1796 gfc_check_a_ikind, gfc_simplify_floor, gfc_resolve_floor,
1797 a, BT_REAL, dr, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
1798
1799 make_generic ("floor", GFC_ISYM_FLOOR, GFC_STD_F95);
1800
1801 /* G77 compatible fnum */
1802 add_sym_1 ("fnum", GFC_ISYM_FNUM, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
1803 di, GFC_STD_GNU, gfc_check_fnum, NULL, gfc_resolve_fnum,
1804 ut, BT_INTEGER, di, REQUIRED);
1805
1806 make_generic ("fnum", GFC_ISYM_FNUM, GFC_STD_GNU);
1807
1808 add_sym_1 ("fraction", GFC_ISYM_FRACTION, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
1809 gfc_check_x, gfc_simplify_fraction, gfc_resolve_fraction,
1810 x, BT_REAL, dr, REQUIRED);
1811
1812 make_generic ("fraction", GFC_ISYM_FRACTION, GFC_STD_F95);
1813
1814 add_sym_2_intent ("fstat", GFC_ISYM_FSTAT, CLASS_IMPURE, ACTUAL_NO,
1815 BT_INTEGER, di, GFC_STD_GNU,
1816 gfc_check_fstat, NULL, gfc_resolve_fstat,
1817 ut, BT_INTEGER, di, REQUIRED, INTENT_IN,
1818 vl, BT_INTEGER, di, REQUIRED, INTENT_OUT);
1819
1820 make_generic ("fstat", GFC_ISYM_FSTAT, GFC_STD_GNU);
1821
1822 add_sym_1 ("ftell", GFC_ISYM_FTELL, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
1823 ii, GFC_STD_GNU, gfc_check_ftell, NULL, gfc_resolve_ftell,
1824 ut, BT_INTEGER, di, REQUIRED);
1825
1826 make_generic ("ftell", GFC_ISYM_FTELL, GFC_STD_GNU);
1827
1828 add_sym_2_intent ("fgetc", GFC_ISYM_FGETC, CLASS_IMPURE, ACTUAL_NO,
1829 BT_INTEGER, di, GFC_STD_GNU,
1830 gfc_check_fgetputc, NULL, gfc_resolve_fgetc,
1831 ut, BT_INTEGER, di, REQUIRED, INTENT_IN,
1832 c, BT_CHARACTER, dc, REQUIRED, INTENT_OUT);
1833
1834 make_generic ("fgetc", GFC_ISYM_FGETC, GFC_STD_GNU);
1835
1836 add_sym_1_intent ("fget", GFC_ISYM_FGET, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
1837 di, GFC_STD_GNU, gfc_check_fgetput, NULL, gfc_resolve_fget,
1838 c, BT_CHARACTER, dc, REQUIRED, INTENT_OUT);
1839
1840 make_generic ("fget", GFC_ISYM_FGET, GFC_STD_GNU);
1841
1842 add_sym_2 ("fputc", GFC_ISYM_FPUTC, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
1843 di, GFC_STD_GNU, gfc_check_fgetputc, NULL, gfc_resolve_fputc,
1844 ut, BT_INTEGER, di, REQUIRED, c, BT_CHARACTER, dc, REQUIRED);
1845
1846 make_generic ("fputc", GFC_ISYM_FPUTC, GFC_STD_GNU);
1847
1848 add_sym_1 ("fput", GFC_ISYM_FPUT, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
1849 di, GFC_STD_GNU, gfc_check_fgetput, NULL, gfc_resolve_fput,
1850 c, BT_CHARACTER, dc, REQUIRED);
1851
1852 make_generic ("fput", GFC_ISYM_FPUT, GFC_STD_GNU);
1853
1854 add_sym_1 ("gamma", GFC_ISYM_TGAMMA, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr,
1855 GFC_STD_F2008, gfc_check_fn_r, gfc_simplify_gamma,
1856 gfc_resolve_gamma, x, BT_REAL, dr, REQUIRED);
1857
1858 add_sym_1 ("dgamma", GFC_ISYM_TGAMMA, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
1859 gfc_check_fn_d, gfc_simplify_gamma, gfc_resolve_gamma,
1860 x, BT_REAL, dr, REQUIRED);
1861
1862 make_generic ("gamma", GFC_ISYM_TGAMMA, GFC_STD_F2008);
1863
1864 /* Unix IDs (g77 compatibility) */
1865 add_sym_1 ("getcwd", GFC_ISYM_GETCWD, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
1866 di, GFC_STD_GNU, NULL, NULL, gfc_resolve_getcwd,
1867 c, BT_CHARACTER, dc, REQUIRED);
1868
1869 make_generic ("getcwd", GFC_ISYM_GETCWD, GFC_STD_GNU);
1870
1871 add_sym_0 ("getgid", GFC_ISYM_GETGID, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
1872 di, GFC_STD_GNU, NULL, NULL, gfc_resolve_getgid);
1873
1874 make_generic ("getgid", GFC_ISYM_GETGID, GFC_STD_GNU);
1875
1876 add_sym_0 ("getpid", GFC_ISYM_GETPID, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
1877 di, GFC_STD_GNU, NULL, NULL, gfc_resolve_getpid);
1878
1879 make_generic ("getpid", GFC_ISYM_GETPID, GFC_STD_GNU);
1880
1881 add_sym_0 ("getuid", GFC_ISYM_GETUID, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
1882 di, GFC_STD_GNU, NULL, NULL, gfc_resolve_getuid);
1883
1884 make_generic ("getuid", GFC_ISYM_GETUID, GFC_STD_GNU);
1885
1886 add_sym_1_intent ("hostnm", GFC_ISYM_HOSTNM, CLASS_IMPURE, ACTUAL_NO,
1887 BT_INTEGER, di, GFC_STD_GNU,
1888 gfc_check_hostnm, NULL, gfc_resolve_hostnm,
1889 c, BT_CHARACTER, dc, REQUIRED, INTENT_OUT);
1890
1891 make_generic ("hostnm", GFC_ISYM_HOSTNM, GFC_STD_GNU);
1892
1893 add_sym_1 ("huge", GFC_ISYM_HUGE, CLASS_INQUIRY, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
1894 gfc_check_huge, gfc_simplify_huge, NULL,
1895 x, BT_UNKNOWN, dr, REQUIRED);
1896
1897 make_generic ("huge", GFC_ISYM_HUGE, GFC_STD_F95);
1898
1899 add_sym_2 ("hypot", GFC_ISYM_HYPOT, CLASS_ELEMENTAL, ACTUAL_NO,
1900 BT_REAL, dr, GFC_STD_F2008,
1901 gfc_check_hypot, gfc_simplify_hypot, gfc_resolve_hypot,
1902 x, BT_REAL, dr, REQUIRED, y, BT_REAL, dr, REQUIRED);
1903
1904 make_generic ("hypot", GFC_ISYM_HYPOT, GFC_STD_F2008);
1905
1906 add_sym_2 ("iachar", GFC_ISYM_IACHAR, CLASS_ELEMENTAL, ACTUAL_NO,
1907 BT_INTEGER, di, GFC_STD_F95,
1908 gfc_check_ichar_iachar, gfc_simplify_iachar, gfc_resolve_iachar,
1909 c, BT_CHARACTER, dc, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
1910
1911 make_generic ("iachar", GFC_ISYM_IACHAR, GFC_STD_F95);
1912
1913 add_sym_2 ("iand", GFC_ISYM_IAND, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
1914 gfc_check_iand, gfc_simplify_iand, gfc_resolve_iand,
1915 i, BT_INTEGER, di, REQUIRED, j, BT_INTEGER, di, REQUIRED);
1916
1917 make_generic ("iand", GFC_ISYM_IAND, GFC_STD_F95);
1918
1919 add_sym_2 ("and", GFC_ISYM_AND, CLASS_IMPURE, ACTUAL_NO, BT_LOGICAL,
1920 dl, GFC_STD_GNU, gfc_check_and, gfc_simplify_and, gfc_resolve_and,
1921 i, BT_UNKNOWN, 0, REQUIRED, j, BT_UNKNOWN, 0, REQUIRED);
1922
1923 make_generic ("and", GFC_ISYM_AND, GFC_STD_GNU);
1924
1925 add_sym_3red ("iall", GFC_ISYM_IALL, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F2008,
1926 gfc_check_transf_bit_intrins, gfc_simplify_iall, gfc_resolve_iall,
1927 ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
1928 msk, BT_LOGICAL, dl, OPTIONAL);
1929
1930 make_generic ("iall", GFC_ISYM_IALL, GFC_STD_F2008);
1931
1932 add_sym_3red ("iany", GFC_ISYM_IANY, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F2008,
1933 gfc_check_transf_bit_intrins, gfc_simplify_iany, gfc_resolve_iany,
1934 ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
1935 msk, BT_LOGICAL, dl, OPTIONAL);
1936
1937 make_generic ("iany", GFC_ISYM_IANY, GFC_STD_F2008);
1938
1939 add_sym_0 ("iargc", GFC_ISYM_IARGC, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
1940 di, GFC_STD_GNU, NULL, NULL, NULL);
1941
1942 make_generic ("iargc", GFC_ISYM_IARGC, GFC_STD_GNU);
1943
1944 add_sym_2 ("ibclr", GFC_ISYM_IBCLR, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
1945 gfc_check_bitfcn, gfc_simplify_ibclr, gfc_resolve_ibclr,
1946 i, BT_INTEGER, di, REQUIRED, pos, BT_INTEGER, di, REQUIRED);
1947
1948 make_generic ("ibclr", GFC_ISYM_IBCLR, GFC_STD_F95);
1949
1950 add_sym_3 ("ibits", GFC_ISYM_IBITS, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
1951 gfc_check_ibits, gfc_simplify_ibits, gfc_resolve_ibits,
1952 i, BT_INTEGER, di, REQUIRED, pos, BT_INTEGER, di, REQUIRED,
1953 ln, BT_INTEGER, di, REQUIRED);
1954
1955 make_generic ("ibits", GFC_ISYM_IBITS, GFC_STD_F95);
1956
1957 add_sym_2 ("ibset", GFC_ISYM_IBSET, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
1958 gfc_check_bitfcn, gfc_simplify_ibset, gfc_resolve_ibset,
1959 i, BT_INTEGER, di, REQUIRED, pos, BT_INTEGER, di, REQUIRED);
1960
1961 make_generic ("ibset", GFC_ISYM_IBSET, GFC_STD_F95);
1962
1963 add_sym_2 ("ichar", GFC_ISYM_ICHAR, CLASS_ELEMENTAL, ACTUAL_NO,
1964 BT_INTEGER, di, GFC_STD_F77,
1965 gfc_check_ichar_iachar, gfc_simplify_ichar, gfc_resolve_ichar,
1966 c, BT_CHARACTER, dc, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
1967
1968 make_generic ("ichar", GFC_ISYM_ICHAR, GFC_STD_F77);
1969
1970 add_sym_2 ("ieor", GFC_ISYM_IEOR, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
1971 gfc_check_ieor, gfc_simplify_ieor, gfc_resolve_ieor,
1972 i, BT_INTEGER, di, REQUIRED, j, BT_INTEGER, di, REQUIRED);
1973
1974 make_generic ("ieor", GFC_ISYM_IEOR, GFC_STD_F95);
1975
1976 add_sym_2 ("xor", GFC_ISYM_XOR, CLASS_IMPURE, ACTUAL_NO, BT_LOGICAL,
1977 dl, GFC_STD_GNU, gfc_check_and, gfc_simplify_xor, gfc_resolve_xor,
1978 i, BT_UNKNOWN, 0, REQUIRED, j, BT_UNKNOWN, 0, REQUIRED);
1979
1980 make_generic ("xor", GFC_ISYM_XOR, GFC_STD_GNU);
1981
1982 add_sym_0 ("ierrno", GFC_ISYM_IERRNO, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
1983 di, GFC_STD_GNU, NULL, NULL, gfc_resolve_ierrno);
1984
1985 make_generic ("ierrno", GFC_ISYM_IERRNO, GFC_STD_GNU);
1986
1987 add_sym_2 ("image_index", GFC_ISYM_IMAGE_INDEX, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F2008,
1988 gfc_check_image_index, gfc_simplify_image_index, gfc_resolve_image_index,
1989 ca, BT_REAL, dr, REQUIRED, sub, BT_INTEGER, ii, REQUIRED);
1990
1991 /* The resolution function for INDEX is called gfc_resolve_index_func
1992 because the name gfc_resolve_index is already used in resolve.c. */
1993 add_sym_4 ("index", GFC_ISYM_INDEX, CLASS_ELEMENTAL, ACTUAL_YES,
1994 BT_INTEGER, di, GFC_STD_F77,
1995 gfc_check_index, gfc_simplify_index, gfc_resolve_index_func,
1996 stg, BT_CHARACTER, dc, REQUIRED, ssg, BT_CHARACTER, dc, REQUIRED,
1997 bck, BT_LOGICAL, dl, OPTIONAL, kind, BT_INTEGER, di, OPTIONAL);
1998
1999 make_generic ("index", GFC_ISYM_INDEX, GFC_STD_F77);
2000
2001 add_sym_2 ("int", GFC_ISYM_INT, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F77,
2002 gfc_check_int, gfc_simplify_int, gfc_resolve_int,
2003 a, BT_REAL, dr, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
2004
2005 add_sym_1 ("ifix", GFC_ISYM_INT, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F77,
2006 NULL, gfc_simplify_ifix, NULL,
2007 a, BT_REAL, dr, REQUIRED);
2008
2009 add_sym_1 ("idint", GFC_ISYM_INT, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F77,
2010 NULL, gfc_simplify_idint, NULL,
2011 a, BT_REAL, dd, REQUIRED);
2012
2013 make_generic ("int", GFC_ISYM_INT, GFC_STD_F77);
2014
2015 add_sym_1 ("int2", GFC_ISYM_INT2, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU,
2016 gfc_check_intconv, gfc_simplify_int2, gfc_resolve_int2,
2017 a, BT_REAL, dr, REQUIRED);
2018
2019 make_alias ("short", GFC_STD_GNU);
2020
2021 make_generic ("int2", GFC_ISYM_INT2, GFC_STD_GNU);
2022
2023 add_sym_1 ("int8", GFC_ISYM_INT8, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU,
2024 gfc_check_intconv, gfc_simplify_int8, gfc_resolve_int8,
2025 a, BT_REAL, dr, REQUIRED);
2026
2027 make_generic ("int8", GFC_ISYM_INT8, GFC_STD_GNU);
2028
2029 add_sym_1 ("long", GFC_ISYM_LONG, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU,
2030 gfc_check_intconv, gfc_simplify_long, gfc_resolve_long,
2031 a, BT_REAL, dr, REQUIRED);
2032
2033 make_generic ("long", GFC_ISYM_LONG, GFC_STD_GNU);
2034
2035 add_sym_2 ("ior", GFC_ISYM_IOR, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
2036 gfc_check_ior, gfc_simplify_ior, gfc_resolve_ior,
2037 i, BT_INTEGER, di, REQUIRED, j, BT_INTEGER, di, REQUIRED);
2038
2039 make_generic ("ior", GFC_ISYM_IOR, GFC_STD_F95);
2040
2041 add_sym_2 ("or", GFC_ISYM_OR, CLASS_IMPURE, ACTUAL_NO, BT_LOGICAL,
2042 dl, GFC_STD_GNU, gfc_check_and, gfc_simplify_or, gfc_resolve_or,
2043 i, BT_UNKNOWN, 0, REQUIRED, j, BT_UNKNOWN, 0, REQUIRED);
2044
2045 make_generic ("or", GFC_ISYM_OR, GFC_STD_GNU);
2046
2047 add_sym_3red ("iparity", GFC_ISYM_IPARITY, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F2008,
2048 gfc_check_transf_bit_intrins, gfc_simplify_iparity, gfc_resolve_iparity,
2049 ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
2050 msk, BT_LOGICAL, dl, OPTIONAL);
2051
2052 make_generic ("iparity", GFC_ISYM_IPARITY, GFC_STD_F2008);
2053
2054 /* The following function is for G77 compatibility. */
2055 add_sym_1 ("irand", GFC_ISYM_IRAND, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
2056 4, GFC_STD_GNU, gfc_check_irand, NULL, NULL,
2057 i, BT_INTEGER, 4, OPTIONAL);
2058
2059 make_generic ("irand", GFC_ISYM_IRAND, GFC_STD_GNU);
2060
2061 add_sym_1 ("isatty", GFC_ISYM_ISATTY, CLASS_IMPURE, ACTUAL_NO, BT_LOGICAL,
2062 dl, GFC_STD_GNU, gfc_check_isatty, NULL, gfc_resolve_isatty,
2063 ut, BT_INTEGER, di, REQUIRED);
2064
2065 make_generic ("isatty", GFC_ISYM_ISATTY, GFC_STD_GNU);
2066
2067 add_sym_1 ("is_iostat_end", GFC_ISYM_IS_IOSTAT_END,
2068 CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F2003,
2069 gfc_check_i, gfc_simplify_is_iostat_end, NULL,
2070 i, BT_INTEGER, 0, REQUIRED);
2071
2072 make_generic ("is_iostat_end", GFC_ISYM_IS_IOSTAT_END, GFC_STD_F2003);
2073
2074 add_sym_1 ("is_iostat_eor", GFC_ISYM_IS_IOSTAT_EOR,
2075 CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F2003,
2076 gfc_check_i, gfc_simplify_is_iostat_eor, NULL,
2077 i, BT_INTEGER, 0, REQUIRED);
2078
2079 make_generic ("is_iostat_eor", GFC_ISYM_IS_IOSTAT_EOR, GFC_STD_F2003);
2080
2081 add_sym_1 ("isnan", GFC_ISYM_ISNAN, CLASS_ELEMENTAL, ACTUAL_NO,
2082 BT_LOGICAL, dl, GFC_STD_GNU,
2083 gfc_check_isnan, gfc_simplify_isnan, NULL,
2084 x, BT_REAL, 0, REQUIRED);
2085
2086 make_generic ("isnan", GFC_ISYM_ISNAN, GFC_STD_GNU);
2087
2088 add_sym_2 ("rshift", GFC_ISYM_RSHIFT, CLASS_ELEMENTAL, ACTUAL_NO,
2089 BT_INTEGER, di, GFC_STD_GNU,
2090 gfc_check_ishft, gfc_simplify_rshift, gfc_resolve_rshift,
2091 i, BT_INTEGER, di, REQUIRED, sh, BT_INTEGER, di, REQUIRED);
2092
2093 make_generic ("rshift", GFC_ISYM_RSHIFT, GFC_STD_GNU);
2094
2095 add_sym_2 ("lshift", GFC_ISYM_LSHIFT, CLASS_ELEMENTAL, ACTUAL_NO,
2096 BT_INTEGER, di, GFC_STD_GNU,
2097 gfc_check_ishft, gfc_simplify_lshift, gfc_resolve_lshift,
2098 i, BT_INTEGER, di, REQUIRED, sh, BT_INTEGER, di, REQUIRED);
2099
2100 make_generic ("lshift", GFC_ISYM_LSHIFT, GFC_STD_GNU);
2101
2102 add_sym_2 ("ishft", GFC_ISYM_ISHFT, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
2103 gfc_check_ishft, gfc_simplify_ishft, gfc_resolve_ishft,
2104 i, BT_INTEGER, di, REQUIRED, sh, BT_INTEGER, di, REQUIRED);
2105
2106 make_generic ("ishft", GFC_ISYM_ISHFT, GFC_STD_F95);
2107
2108 add_sym_3 ("ishftc", GFC_ISYM_ISHFTC, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
2109 gfc_check_ishftc, gfc_simplify_ishftc, gfc_resolve_ishftc,
2110 i, BT_INTEGER, di, REQUIRED, sh, BT_INTEGER, di, REQUIRED,
2111 sz, BT_INTEGER, di, OPTIONAL);
2112
2113 make_generic ("ishftc", GFC_ISYM_ISHFTC, GFC_STD_F95);
2114
2115 add_sym_2 ("kill", GFC_ISYM_KILL, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
2116 di, GFC_STD_GNU, gfc_check_kill, NULL, gfc_resolve_kill,
2117 a, BT_INTEGER, di, REQUIRED, b, BT_INTEGER, di, REQUIRED);
2118
2119 make_generic ("kill", GFC_ISYM_KILL, GFC_STD_GNU);
2120
2121 add_sym_1 ("kind", GFC_ISYM_KIND, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
2122 gfc_check_kind, gfc_simplify_kind, NULL,
2123 x, BT_REAL, dr, REQUIRED);
2124
2125 make_generic ("kind", GFC_ISYM_KIND, GFC_STD_F95);
2126
2127 add_sym_3 ("lbound", GFC_ISYM_LBOUND, CLASS_INQUIRY, ACTUAL_NO,
2128 BT_INTEGER, di, GFC_STD_F95,
2129 gfc_check_lbound, gfc_simplify_lbound, gfc_resolve_lbound,
2130 ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, di, OPTIONAL,
2131 kind, BT_INTEGER, di, OPTIONAL);
2132
2133 make_generic ("lbound", GFC_ISYM_LBOUND, GFC_STD_F95);
2134
2135 add_sym_3 ("lcobound", GFC_ISYM_LCOBOUND, CLASS_INQUIRY, ACTUAL_NO,
2136 BT_INTEGER, di, GFC_STD_F2008,
2137 gfc_check_lcobound, gfc_simplify_lcobound, gfc_resolve_lcobound,
2138 ca, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
2139 kind, BT_INTEGER, di, OPTIONAL);
2140
2141 make_generic ("lcobound", GFC_ISYM_LCOBOUND, GFC_STD_F2008);
2142
2143 add_sym_1 ("leadz", GFC_ISYM_LEADZ, CLASS_ELEMENTAL, ACTUAL_NO,
2144 BT_INTEGER, di, GFC_STD_F2008,
2145 gfc_check_i, gfc_simplify_leadz, NULL,
2146 i, BT_INTEGER, di, REQUIRED);
2147
2148 make_generic ("leadz", GFC_ISYM_LEADZ, GFC_STD_F2008);
2149
2150 add_sym_2 ("len", GFC_ISYM_LEN, CLASS_INQUIRY, ACTUAL_YES,
2151 BT_INTEGER, di, GFC_STD_F77,
2152 gfc_check_len_lentrim, gfc_simplify_len, gfc_resolve_len,
2153 stg, BT_CHARACTER, dc, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
2154
2155 make_generic ("len", GFC_ISYM_LEN, GFC_STD_F77);
2156
2157 add_sym_2 ("len_trim", GFC_ISYM_LEN_TRIM, CLASS_ELEMENTAL, ACTUAL_NO,
2158 BT_INTEGER, di, GFC_STD_F95,
2159 gfc_check_len_lentrim, gfc_simplify_len_trim, gfc_resolve_len_trim,
2160 stg, BT_CHARACTER, dc, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
2161
2162 make_alias ("lnblnk", GFC_STD_GNU);
2163
2164 make_generic ("len_trim", GFC_ISYM_LEN_TRIM, GFC_STD_F95);
2165
2166 add_sym_1 ("lgamma", GFC_ISYM_LGAMMA, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL,
2167 dr, GFC_STD_GNU,
2168 gfc_check_fn_r, gfc_simplify_lgamma, gfc_resolve_lgamma,
2169 x, BT_REAL, dr, REQUIRED);
2170
2171 make_alias ("log_gamma", GFC_STD_F2008);
2172
2173 add_sym_1 ("algama", GFC_ISYM_LGAMMA, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
2174 gfc_check_fn_r, gfc_simplify_lgamma, gfc_resolve_lgamma,
2175 x, BT_REAL, dr, REQUIRED);
2176
2177 add_sym_1 ("dlgama", GFC_ISYM_LGAMMA, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
2178 gfc_check_fn_d, gfc_simplify_lgamma, gfc_resolve_lgamma,
2179 x, BT_REAL, dr, REQUIRED);
2180
2181 make_generic ("log_gamma", GFC_ISYM_LGAMMA, GFC_STD_F2008);
2182
2183
2184 add_sym_2 ("lge", GFC_ISYM_LGE, CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl,
2185 GFC_STD_F77, gfc_check_lge_lgt_lle_llt, gfc_simplify_lge, NULL,
2186 sta, BT_CHARACTER, dc, REQUIRED, stb, BT_CHARACTER, dc, REQUIRED);
2187
2188 make_generic ("lge", GFC_ISYM_LGE, GFC_STD_F77);
2189
2190 add_sym_2 ("lgt", GFC_ISYM_LGT, CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl,
2191 GFC_STD_F77, gfc_check_lge_lgt_lle_llt, gfc_simplify_lgt, NULL,
2192 sta, BT_CHARACTER, dc, REQUIRED, stb, BT_CHARACTER, dc, REQUIRED);
2193
2194 make_generic ("lgt", GFC_ISYM_LGT, GFC_STD_F77);
2195
2196 add_sym_2 ("lle",GFC_ISYM_LLE, CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl,
2197 GFC_STD_F77, gfc_check_lge_lgt_lle_llt, gfc_simplify_lle, NULL,
2198 sta, BT_CHARACTER, dc, REQUIRED, stb, BT_CHARACTER, dc, REQUIRED);
2199
2200 make_generic ("lle", GFC_ISYM_LLE, GFC_STD_F77);
2201
2202 add_sym_2 ("llt", GFC_ISYM_LLT, CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl,
2203 GFC_STD_F77, gfc_check_lge_lgt_lle_llt, gfc_simplify_llt, NULL,
2204 sta, BT_CHARACTER, dc, REQUIRED, stb, BT_CHARACTER, dc, REQUIRED);
2205
2206 make_generic ("llt", GFC_ISYM_LLT, GFC_STD_F77);
2207
2208 add_sym_2 ("link", GFC_ISYM_LINK, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, di,
2209 GFC_STD_GNU, gfc_check_link, NULL, gfc_resolve_link,
2210 p1, BT_CHARACTER, dc, REQUIRED, p2, BT_CHARACTER, dc, REQUIRED);
2211
2212 make_generic ("link", GFC_ISYM_LINK, GFC_STD_GNU);
2213
2214 add_sym_1 ("log", GFC_ISYM_LOG, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F77,
2215 gfc_check_fn_rc, gfc_simplify_log, gfc_resolve_log,
2216 x, BT_REAL, dr, REQUIRED);
2217
2218 add_sym_1 ("alog", GFC_ISYM_LOG, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
2219 NULL, gfc_simplify_log, gfc_resolve_log,
2220 x, BT_REAL, dr, REQUIRED);
2221
2222 add_sym_1 ("dlog", GFC_ISYM_LOG, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
2223 gfc_check_fn_d, gfc_simplify_log, gfc_resolve_log,
2224 x, BT_REAL, dd, REQUIRED);
2225
2226 add_sym_1 ("clog", GFC_ISYM_LOG, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dz, GFC_STD_F77,
2227 NULL, gfc_simplify_log, gfc_resolve_log,
2228 x, BT_COMPLEX, dz, REQUIRED);
2229
2230 add_sym_1 ("zlog", GFC_ISYM_LOG, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dd, GFC_STD_GNU,
2231 NULL, gfc_simplify_log, gfc_resolve_log,
2232 x, BT_COMPLEX, dd, REQUIRED);
2233
2234 make_alias ("cdlog", GFC_STD_GNU);
2235
2236 make_generic ("log", GFC_ISYM_LOG, GFC_STD_F77);
2237
2238 add_sym_1 ("log10", GFC_ISYM_LOG10, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F77,
2239 gfc_check_fn_r, gfc_simplify_log10, gfc_resolve_log10,
2240 x, BT_REAL, dr, REQUIRED);
2241
2242 add_sym_1 ("alog10", GFC_ISYM_LOG10, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
2243 NULL, gfc_simplify_log10, gfc_resolve_log10,
2244 x, BT_REAL, dr, REQUIRED);
2245
2246 add_sym_1 ("dlog10", GFC_ISYM_LOG10, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
2247 gfc_check_fn_d, gfc_simplify_log10, gfc_resolve_log10,
2248 x, BT_REAL, dd, REQUIRED);
2249
2250 make_generic ("log10", GFC_ISYM_LOG10, GFC_STD_F77);
2251
2252 add_sym_2 ("logical", GFC_ISYM_LOGICAL, CLASS_ELEMENTAL, ACTUAL_NO, BT_LOGICAL, dl, GFC_STD_F95,
2253 gfc_check_logical, gfc_simplify_logical, gfc_resolve_logical,
2254 l, BT_LOGICAL, dl, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
2255
2256 make_generic ("logical", GFC_ISYM_LOGICAL, GFC_STD_F95);
2257
2258 add_sym_2_intent ("lstat", GFC_ISYM_LSTAT, CLASS_IMPURE, ACTUAL_NO,
2259 BT_INTEGER, di, GFC_STD_GNU,
2260 gfc_check_stat, NULL, gfc_resolve_lstat,
2261 nm, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
2262 vl, BT_INTEGER, di, REQUIRED, INTENT_OUT);
2263
2264 make_generic ("lstat", GFC_ISYM_LSTAT, GFC_STD_GNU);
2265
2266 add_sym_1 ("malloc", GFC_ISYM_MALLOC, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, ii,
2267 GFC_STD_GNU, gfc_check_malloc, NULL, gfc_resolve_malloc,
2268 sz, BT_INTEGER, di, REQUIRED);
2269
2270 make_generic ("malloc", GFC_ISYM_MALLOC, GFC_STD_GNU);
2271
2272 add_sym_2 ("maskl", GFC_ISYM_MASKL, CLASS_ELEMENTAL, ACTUAL_NO,
2273 BT_INTEGER, di, GFC_STD_F2008,
2274 gfc_check_mask, gfc_simplify_maskl, gfc_resolve_mask,
2275 i, BT_INTEGER, di, REQUIRED,
2276 kind, BT_INTEGER, di, OPTIONAL);
2277
2278 make_generic ("maskl", GFC_ISYM_MASKL, GFC_STD_F2008);
2279
2280 add_sym_2 ("maskr", GFC_ISYM_MASKR, CLASS_ELEMENTAL, ACTUAL_NO,
2281 BT_INTEGER, di, GFC_STD_F2008,
2282 gfc_check_mask, gfc_simplify_maskr, gfc_resolve_mask,
2283 i, BT_INTEGER, di, REQUIRED,
2284 kind, BT_INTEGER, di, OPTIONAL);
2285
2286 make_generic ("maskr", GFC_ISYM_MASKR, GFC_STD_F2008);
2287
2288 add_sym_2 ("matmul", GFC_ISYM_MATMUL, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2289 gfc_check_matmul, gfc_simplify_matmul, gfc_resolve_matmul,
2290 ma, BT_REAL, dr, REQUIRED, mb, BT_REAL, dr, REQUIRED);
2291
2292 make_generic ("matmul", GFC_ISYM_MATMUL, GFC_STD_F95);
2293
2294 /* Note: amax0 is equivalent to real(max), max1 is equivalent to
2295 int(max). The max function must take at least two arguments. */
2296
2297 add_sym_1m ("max", GFC_ISYM_MAX, CLASS_ELEMENTAL, ACTUAL_NO, BT_UNKNOWN, 0, GFC_STD_F77,
2298 gfc_check_min_max, gfc_simplify_max, gfc_resolve_max,
2299 a1, BT_UNKNOWN, dr, REQUIRED, a2, BT_UNKNOWN, dr, REQUIRED);
2300
2301 add_sym_1m ("max0", GFC_ISYM_MAX, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F77,
2302 gfc_check_min_max_integer, gfc_simplify_max, NULL,
2303 a1, BT_INTEGER, di, REQUIRED, a2, BT_INTEGER, di, REQUIRED);
2304
2305 add_sym_1m ("amax0", GFC_ISYM_MAX, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F77,
2306 gfc_check_min_max_integer, gfc_simplify_max, NULL,
2307 a1, BT_INTEGER, di, REQUIRED, a2, BT_INTEGER, di, REQUIRED);
2308
2309 add_sym_1m ("amax1", GFC_ISYM_MAX, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F77,
2310 gfc_check_min_max_real, gfc_simplify_max, NULL,
2311 a1, BT_REAL, dr, REQUIRED, a2, BT_REAL, dr, REQUIRED);
2312
2313 add_sym_1m ("max1", GFC_ISYM_MAX, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F77,
2314 gfc_check_min_max_real, gfc_simplify_max, NULL,
2315 a1, BT_REAL, dr, REQUIRED, a2, BT_REAL, dr, REQUIRED);
2316
2317 add_sym_1m ("dmax1", GFC_ISYM_MAX, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_F77,
2318 gfc_check_min_max_double, gfc_simplify_max, NULL,
2319 a1, BT_REAL, dd, REQUIRED, a2, BT_REAL, dd, REQUIRED);
2320
2321 make_generic ("max", GFC_ISYM_MAX, GFC_STD_F77);
2322
2323 add_sym_1 ("maxexponent", GFC_ISYM_MAXEXPONENT, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di,
2324 GFC_STD_F95, gfc_check_x, gfc_simplify_maxexponent, NULL,
2325 x, BT_UNKNOWN, dr, REQUIRED);
2326
2327 make_generic ("maxexponent", GFC_ISYM_MAXEXPONENT, GFC_STD_F95);
2328
2329 add_sym_3ml ("maxloc", GFC_ISYM_MAXLOC, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
2330 gfc_check_minloc_maxloc, NULL, gfc_resolve_maxloc,
2331 ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
2332 msk, BT_LOGICAL, dl, OPTIONAL);
2333
2334 make_generic ("maxloc", GFC_ISYM_MAXLOC, GFC_STD_F95);
2335
2336 add_sym_3red ("maxval", GFC_ISYM_MAXVAL, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2337 gfc_check_minval_maxval, gfc_simplify_maxval, gfc_resolve_maxval,
2338 ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
2339 msk, BT_LOGICAL, dl, OPTIONAL);
2340
2341 make_generic ("maxval", GFC_ISYM_MAXVAL, GFC_STD_F95);
2342
2343 add_sym_0 ("mclock", GFC_ISYM_MCLOCK, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, di,
2344 GFC_STD_GNU, NULL, NULL, gfc_resolve_mclock);
2345
2346 make_generic ("mclock", GFC_ISYM_MCLOCK, GFC_STD_GNU);
2347
2348 add_sym_0 ("mclock8", GFC_ISYM_MCLOCK8, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
2349 di, GFC_STD_GNU, NULL, NULL, gfc_resolve_mclock8);
2350
2351 make_generic ("mclock8", GFC_ISYM_MCLOCK8, GFC_STD_GNU);
2352
2353 add_sym_3 ("merge", GFC_ISYM_MERGE, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2354 gfc_check_merge, gfc_simplify_merge, gfc_resolve_merge,
2355 ts, BT_REAL, dr, REQUIRED, fs, BT_REAL, dr, REQUIRED,
2356 msk, BT_LOGICAL, dl, REQUIRED);
2357
2358 make_generic ("merge", GFC_ISYM_MERGE, GFC_STD_F95);
2359
2360 add_sym_3 ("merge_bits", GFC_ISYM_MERGE_BITS, CLASS_ELEMENTAL, ACTUAL_NO,
2361 BT_INTEGER, di, GFC_STD_F2008,
2362 gfc_check_merge_bits, gfc_simplify_merge_bits,
2363 gfc_resolve_merge_bits,
2364 i, BT_INTEGER, di, REQUIRED,
2365 j, BT_INTEGER, di, REQUIRED,
2366 msk, BT_INTEGER, di, REQUIRED);
2367
2368 make_generic ("merge_bits", GFC_ISYM_MERGE_BITS, GFC_STD_F2008);
2369
2370 /* Note: amin0 is equivalent to real(min), min1 is equivalent to
2371 int(min). */
2372
2373 add_sym_1m ("min", GFC_ISYM_MIN, CLASS_ELEMENTAL, ACTUAL_NO, BT_UNKNOWN, 0, GFC_STD_F77,
2374 gfc_check_min_max, gfc_simplify_min, gfc_resolve_min,
2375 a1, BT_REAL, dr, REQUIRED, a2, BT_REAL, dr, REQUIRED);
2376
2377 add_sym_1m ("min0", GFC_ISYM_MIN, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F77,
2378 gfc_check_min_max_integer, gfc_simplify_min, NULL,
2379 a1, BT_INTEGER, di, REQUIRED, a2, BT_INTEGER, di, REQUIRED);
2380
2381 add_sym_1m ("amin0", GFC_ISYM_MIN, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F77,
2382 gfc_check_min_max_integer, gfc_simplify_min, NULL,
2383 a1, BT_INTEGER, di, REQUIRED, a2, BT_INTEGER, di, REQUIRED);
2384
2385 add_sym_1m ("amin1", GFC_ISYM_MIN, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F77,
2386 gfc_check_min_max_real, gfc_simplify_min, NULL,
2387 a1, BT_REAL, dr, REQUIRED, a2, BT_REAL, dr, REQUIRED);
2388
2389 add_sym_1m ("min1", GFC_ISYM_MIN, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F77,
2390 gfc_check_min_max_real, gfc_simplify_min, NULL,
2391 a1, BT_REAL, dr, REQUIRED, a2, BT_REAL, dr, REQUIRED);
2392
2393 add_sym_1m ("dmin1", GFC_ISYM_MIN, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_F77,
2394 gfc_check_min_max_double, gfc_simplify_min, NULL,
2395 a1, BT_REAL, dd, REQUIRED, a2, BT_REAL, dd, REQUIRED);
2396
2397 make_generic ("min", GFC_ISYM_MIN, GFC_STD_F77);
2398
2399 add_sym_1 ("minexponent", GFC_ISYM_MINEXPONENT, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di,
2400 GFC_STD_F95, gfc_check_x, gfc_simplify_minexponent, NULL,
2401 x, BT_UNKNOWN, dr, REQUIRED);
2402
2403 make_generic ("minexponent", GFC_ISYM_MINEXPONENT, GFC_STD_F95);
2404
2405 add_sym_3ml ("minloc", GFC_ISYM_MINLOC, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
2406 gfc_check_minloc_maxloc, NULL, gfc_resolve_minloc,
2407 ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
2408 msk, BT_LOGICAL, dl, OPTIONAL);
2409
2410 make_generic ("minloc", GFC_ISYM_MINLOC, GFC_STD_F95);
2411
2412 add_sym_3red ("minval", GFC_ISYM_MINVAL, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2413 gfc_check_minval_maxval, gfc_simplify_minval, gfc_resolve_minval,
2414 ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
2415 msk, BT_LOGICAL, dl, OPTIONAL);
2416
2417 make_generic ("minval", GFC_ISYM_MINVAL, GFC_STD_F95);
2418
2419 add_sym_2 ("mod", GFC_ISYM_MOD, CLASS_ELEMENTAL, ACTUAL_YES, BT_INTEGER, di, GFC_STD_F77,
2420 gfc_check_a_p, gfc_simplify_mod, gfc_resolve_mod,
2421 a, BT_INTEGER, di, REQUIRED, p, BT_INTEGER, di, REQUIRED);
2422
2423 add_sym_2 ("amod", GFC_ISYM_MOD, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
2424 NULL, gfc_simplify_mod, gfc_resolve_mod,
2425 a, BT_REAL, dr, REQUIRED, p, BT_REAL, dr, REQUIRED);
2426
2427 add_sym_2 ("dmod", GFC_ISYM_MOD, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
2428 gfc_check_x_yd, gfc_simplify_mod, gfc_resolve_mod,
2429 a, BT_REAL, dd, REQUIRED, p, BT_REAL, dd, REQUIRED);
2430
2431 make_generic ("mod", GFC_ISYM_MOD, GFC_STD_F77);
2432
2433 add_sym_2 ("modulo", GFC_ISYM_MODULO, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, di, GFC_STD_F95,
2434 gfc_check_a_p, gfc_simplify_modulo, gfc_resolve_modulo,
2435 a, BT_REAL, di, REQUIRED, p, BT_REAL, di, REQUIRED);
2436
2437 make_generic ("modulo", GFC_ISYM_MODULO, GFC_STD_F95);
2438
2439 add_sym_2 ("nearest", GFC_ISYM_NEAREST, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2440 gfc_check_nearest, gfc_simplify_nearest, gfc_resolve_nearest,
2441 x, BT_REAL, dr, REQUIRED, s, BT_REAL, dr, REQUIRED);
2442
2443 make_generic ("nearest", GFC_ISYM_NEAREST, GFC_STD_F95);
2444
2445 add_sym_1 ("new_line", GFC_ISYM_NEW_LINE, CLASS_INQUIRY, ACTUAL_NO, BT_CHARACTER, dc,
2446 GFC_STD_F2003, gfc_check_new_line, gfc_simplify_new_line, NULL,
2447 a, BT_CHARACTER, dc, REQUIRED);
2448
2449 make_generic ("new_line", GFC_ISYM_NEW_LINE, GFC_STD_F2003);
2450
2451 add_sym_2 ("nint", GFC_ISYM_NINT, CLASS_ELEMENTAL, ACTUAL_YES, BT_INTEGER, di, GFC_STD_F77,
2452 gfc_check_a_ikind, gfc_simplify_nint, gfc_resolve_nint,
2453 a, BT_REAL, dr, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
2454
2455 add_sym_1 ("idnint", GFC_ISYM_NINT, CLASS_ELEMENTAL, ACTUAL_YES, BT_INTEGER, di, GFC_STD_F77,
2456 gfc_check_idnint, gfc_simplify_idnint, gfc_resolve_idnint,
2457 a, BT_REAL, dd, REQUIRED);
2458
2459 make_generic ("nint", GFC_ISYM_NINT, GFC_STD_F77);
2460
2461 add_sym_1 ("not", GFC_ISYM_NOT, CLASS_ELEMENTAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
2462 gfc_check_i, gfc_simplify_not, gfc_resolve_not,
2463 i, BT_INTEGER, di, REQUIRED);
2464
2465 make_generic ("not", GFC_ISYM_NOT, GFC_STD_F95);
2466
2467 add_sym_2 ("norm2", GFC_ISYM_NORM2, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr,
2468 GFC_STD_F2008, gfc_check_norm2, gfc_simplify_norm2, gfc_resolve_norm2,
2469 x, BT_REAL, dr, REQUIRED,
2470 dm, BT_INTEGER, ii, OPTIONAL);
2471
2472 make_generic ("norm2", GFC_ISYM_NORM2, GFC_STD_F2008);
2473
2474 add_sym_1 ("null", GFC_ISYM_NULL, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
2475 gfc_check_null, gfc_simplify_null, NULL,
2476 mo, BT_INTEGER, di, OPTIONAL);
2477
2478 make_generic ("null", GFC_ISYM_NULL, GFC_STD_F95);
2479
2480 add_sym_0 ("num_images", GFC_ISYM_NUM_IMAGES, CLASS_INQUIRY, ACTUAL_NO,
2481 BT_INTEGER, di, GFC_STD_F2008,
2482 NULL, gfc_simplify_num_images, NULL);
2483
2484 add_sym_3 ("pack", GFC_ISYM_PACK, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2485 gfc_check_pack, gfc_simplify_pack, gfc_resolve_pack,
2486 ar, BT_REAL, dr, REQUIRED, msk, BT_LOGICAL, dl, REQUIRED,
2487 v, BT_REAL, dr, OPTIONAL);
2488
2489 make_generic ("pack", GFC_ISYM_PACK, GFC_STD_F95);
2490
2491
2492 add_sym_2 ("parity", GFC_ISYM_PARITY, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_LOGICAL, dl,
2493 GFC_STD_F2008, gfc_check_parity, gfc_simplify_parity, gfc_resolve_parity,
2494 msk, BT_LOGICAL, dl, REQUIRED,
2495 dm, BT_INTEGER, ii, OPTIONAL);
2496
2497 make_generic ("parity", GFC_ISYM_PARITY, GFC_STD_F2008);
2498
2499 add_sym_1 ("popcnt", GFC_ISYM_POPCNT, CLASS_ELEMENTAL, ACTUAL_NO,
2500 BT_INTEGER, di, GFC_STD_F2008,
2501 gfc_check_i, gfc_simplify_popcnt, NULL,
2502 i, BT_INTEGER, di, REQUIRED);
2503
2504 make_generic ("popcnt", GFC_ISYM_POPCNT, GFC_STD_F2008);
2505
2506 add_sym_1 ("poppar", GFC_ISYM_POPPAR, CLASS_ELEMENTAL, ACTUAL_NO,
2507 BT_INTEGER, di, GFC_STD_F2008,
2508 gfc_check_i, gfc_simplify_poppar, NULL,
2509 i, BT_INTEGER, di, REQUIRED);
2510
2511 make_generic ("poppar", GFC_ISYM_POPPAR, GFC_STD_F2008);
2512
2513 add_sym_1 ("precision", GFC_ISYM_PRECISION, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
2514 gfc_check_precision, gfc_simplify_precision, NULL,
2515 x, BT_UNKNOWN, 0, REQUIRED);
2516
2517 make_generic ("precision", GFC_ISYM_PRECISION, GFC_STD_F95);
2518
2519 add_sym_1_intent ("present", GFC_ISYM_PRESENT, CLASS_INQUIRY, ACTUAL_NO,
2520 BT_LOGICAL, dl, GFC_STD_F95, gfc_check_present, NULL, NULL,
2521 a, BT_REAL, dr, REQUIRED, INTENT_UNKNOWN);
2522
2523 make_generic ("present", GFC_ISYM_PRESENT, GFC_STD_F95);
2524
2525 add_sym_3red ("product", GFC_ISYM_PRODUCT, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2526 gfc_check_product_sum, gfc_simplify_product, gfc_resolve_product,
2527 ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
2528 msk, BT_LOGICAL, dl, OPTIONAL);
2529
2530 make_generic ("product", GFC_ISYM_PRODUCT, GFC_STD_F95);
2531
2532 add_sym_1 ("radix", GFC_ISYM_RADIX, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
2533 gfc_check_radix, gfc_simplify_radix, NULL,
2534 x, BT_UNKNOWN, 0, REQUIRED);
2535
2536 make_generic ("radix", GFC_ISYM_RADIX, GFC_STD_F95);
2537
2538 /* The following function is for G77 compatibility. */
2539 add_sym_1 ("rand", GFC_ISYM_RAND, CLASS_IMPURE, ACTUAL_NO, BT_REAL,
2540 4, GFC_STD_GNU, gfc_check_rand, NULL, NULL,
2541 i, BT_INTEGER, 4, OPTIONAL);
2542
2543 /* Compatibility with HP FORTRAN 77/iX Reference. Note, rand() and ran()
2544 use slightly different shoddy multiplicative congruential PRNG. */
2545 make_alias ("ran", GFC_STD_GNU);
2546
2547 make_generic ("rand", GFC_ISYM_RAND, GFC_STD_GNU);
2548
2549 add_sym_1 ("range", GFC_ISYM_RANGE, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
2550 gfc_check_range, gfc_simplify_range, NULL,
2551 x, BT_REAL, dr, REQUIRED);
2552
2553 make_generic ("range", GFC_ISYM_RANGE, GFC_STD_F95);
2554
2555 add_sym_1 ("rank", GFC_ISYM_RANK, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di,
2556 GFC_STD_F2008_TS, gfc_check_rank, gfc_simplify_rank, gfc_resolve_rank,
2557 a, BT_REAL, dr, REQUIRED);
2558 make_generic ("rank", GFC_ISYM_RANK, GFC_STD_F2008_TS);
2559
2560 add_sym_2 ("real", GFC_ISYM_REAL, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F77,
2561 gfc_check_real, gfc_simplify_real, gfc_resolve_real,
2562 a, BT_UNKNOWN, dr, REQUIRED, kind, BT_INTEGER, di, OPTIONAL);
2563
2564 /* This provides compatibility with g77. */
2565 add_sym_1 ("realpart", GFC_ISYM_REAL, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_GNU,
2566 gfc_check_fn_c, gfc_simplify_realpart, gfc_resolve_realpart,
2567 a, BT_UNKNOWN, dr, REQUIRED);
2568
2569 add_sym_1 ("float", GFC_ISYM_REAL, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F77,
2570 gfc_check_float, gfc_simplify_float, NULL,
2571 a, BT_INTEGER, di, REQUIRED);
2572
2573 add_sym_1 ("dfloat", GFC_ISYM_REAL, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dd, GFC_STD_GNU,
2574 gfc_check_float, gfc_simplify_dble, gfc_resolve_dble,
2575 a, BT_REAL, dr, REQUIRED);
2576
2577 add_sym_1 ("sngl", GFC_ISYM_REAL, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F77,
2578 gfc_check_sngl, gfc_simplify_sngl, NULL,
2579 a, BT_REAL, dd, REQUIRED);
2580
2581 make_generic ("real", GFC_ISYM_REAL, GFC_STD_F77);
2582
2583 add_sym_2 ("rename", GFC_ISYM_RENAME, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, di,
2584 GFC_STD_GNU, gfc_check_rename, NULL, gfc_resolve_rename,
2585 p1, BT_CHARACTER, dc, REQUIRED, p2, BT_CHARACTER, dc, REQUIRED);
2586
2587 make_generic ("rename", GFC_ISYM_RENAME, GFC_STD_GNU);
2588
2589 add_sym_2 ("repeat", GFC_ISYM_REPEAT, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_CHARACTER, dc, GFC_STD_F95,
2590 gfc_check_repeat, gfc_simplify_repeat, gfc_resolve_repeat,
2591 stg, BT_CHARACTER, dc, REQUIRED, ncopies, BT_INTEGER, di, REQUIRED);
2592
2593 make_generic ("repeat", GFC_ISYM_REPEAT, GFC_STD_F95);
2594
2595 add_sym_4 ("reshape", GFC_ISYM_RESHAPE, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2596 gfc_check_reshape, gfc_simplify_reshape, gfc_resolve_reshape,
2597 src, BT_REAL, dr, REQUIRED, shp, BT_INTEGER, ii, REQUIRED,
2598 pad, BT_REAL, dr, OPTIONAL, ord, BT_INTEGER, ii, OPTIONAL);
2599
2600 make_generic ("reshape", GFC_ISYM_RESHAPE, GFC_STD_F95);
2601
2602 add_sym_1 ("rrspacing", GFC_ISYM_RRSPACING, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2603 gfc_check_x, gfc_simplify_rrspacing, gfc_resolve_rrspacing,
2604 x, BT_REAL, dr, REQUIRED);
2605
2606 make_generic ("rrspacing", GFC_ISYM_RRSPACING, GFC_STD_F95);
2607
2608 add_sym_2 ("same_type_as", GFC_ISYM_SAME_TYPE_AS, CLASS_INQUIRY, ACTUAL_NO,
2609 BT_LOGICAL, dl, GFC_STD_F2003,
2610 gfc_check_same_type_as, gfc_simplify_same_type_as, NULL,
2611 a, BT_UNKNOWN, 0, REQUIRED,
2612 b, BT_UNKNOWN, 0, REQUIRED);
2613
2614 add_sym_2 ("scale", GFC_ISYM_SCALE, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2615 gfc_check_scale, gfc_simplify_scale, gfc_resolve_scale,
2616 x, BT_REAL, dr, REQUIRED, i, BT_INTEGER, di, REQUIRED);
2617
2618 make_generic ("scale", GFC_ISYM_SCALE, GFC_STD_F95);
2619
2620 add_sym_4 ("scan", GFC_ISYM_SCAN, CLASS_ELEMENTAL, ACTUAL_NO,
2621 BT_INTEGER, di, GFC_STD_F95,
2622 gfc_check_scan, gfc_simplify_scan, gfc_resolve_scan,
2623 stg, BT_CHARACTER, dc, REQUIRED, set, BT_CHARACTER, dc, REQUIRED,
2624 bck, BT_LOGICAL, dl, OPTIONAL, kind, BT_INTEGER, di, OPTIONAL);
2625
2626 make_generic ("scan", GFC_ISYM_SCAN, GFC_STD_F95);
2627
2628 /* Added for G77 compatibility garbage. */
2629 add_sym_0 ("second", GFC_ISYM_SECOND, CLASS_IMPURE, ACTUAL_NO, BT_REAL,
2630 4, GFC_STD_GNU, NULL, NULL, NULL);
2631
2632 make_generic ("second", GFC_ISYM_SECOND, GFC_STD_GNU);
2633
2634 /* Added for G77 compatibility. */
2635 add_sym_1 ("secnds", GFC_ISYM_SECNDS, CLASS_IMPURE, ACTUAL_NO, BT_REAL,
2636 dr, GFC_STD_GNU, gfc_check_secnds, NULL, gfc_resolve_secnds,
2637 x, BT_REAL, dr, REQUIRED);
2638
2639 make_generic ("secnds", GFC_ISYM_SECNDS, GFC_STD_GNU);
2640
2641 add_sym_1 ("selected_char_kind", GFC_ISYM_SC_KIND, CLASS_TRANSFORMATIONAL,
2642 ACTUAL_NO, BT_INTEGER, di, GFC_STD_F2003,
2643 gfc_check_selected_char_kind, gfc_simplify_selected_char_kind,
2644 NULL, nm, BT_CHARACTER, dc, REQUIRED);
2645
2646 make_generic ("selected_char_kind", GFC_ISYM_SC_KIND, GFC_STD_F2003);
2647
2648 add_sym_1 ("selected_int_kind", GFC_ISYM_SI_KIND, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di,
2649 GFC_STD_F95, gfc_check_selected_int_kind,
2650 gfc_simplify_selected_int_kind, NULL, r, BT_INTEGER, di, REQUIRED);
2651
2652 make_generic ("selected_int_kind", GFC_ISYM_SI_KIND, GFC_STD_F95);
2653
2654 add_sym_3 ("selected_real_kind", GFC_ISYM_SR_KIND, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di,
2655 GFC_STD_F95, gfc_check_selected_real_kind,
2656 gfc_simplify_selected_real_kind, NULL,
2657 p, BT_INTEGER, di, OPTIONAL, r, BT_INTEGER, di, OPTIONAL,
2658 "radix", BT_INTEGER, di, OPTIONAL);
2659
2660 make_generic ("selected_real_kind", GFC_ISYM_SR_KIND, GFC_STD_F95);
2661
2662 add_sym_2 ("set_exponent", GFC_ISYM_SET_EXPONENT, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2663 gfc_check_set_exponent, gfc_simplify_set_exponent,
2664 gfc_resolve_set_exponent,
2665 x, BT_REAL, dr, REQUIRED, i, BT_INTEGER, di, REQUIRED);
2666
2667 make_generic ("set_exponent", GFC_ISYM_SET_EXPONENT, GFC_STD_F95);
2668
2669 add_sym_2 ("shape", GFC_ISYM_SHAPE, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95,
2670 gfc_check_shape, gfc_simplify_shape, gfc_resolve_shape,
2671 src, BT_REAL, dr, REQUIRED,
2672 kind, BT_INTEGER, di, OPTIONAL);
2673
2674 make_generic ("shape", GFC_ISYM_SHAPE, GFC_STD_F95);
2675
2676 add_sym_2 ("shifta", GFC_ISYM_SHIFTA, CLASS_ELEMENTAL, ACTUAL_NO,
2677 BT_INTEGER, di, GFC_STD_F2008,
2678 gfc_check_shift, gfc_simplify_shifta, gfc_resolve_shift,
2679 i, BT_INTEGER, di, REQUIRED,
2680 sh, BT_INTEGER, di, REQUIRED);
2681
2682 make_generic ("shifta", GFC_ISYM_SHIFTA, GFC_STD_F2008);
2683
2684 add_sym_2 ("shiftl", GFC_ISYM_SHIFTL, CLASS_ELEMENTAL, ACTUAL_NO,
2685 BT_INTEGER, di, GFC_STD_F2008,
2686 gfc_check_shift, gfc_simplify_shiftl, gfc_resolve_shift,
2687 i, BT_INTEGER, di, REQUIRED,
2688 sh, BT_INTEGER, di, REQUIRED);
2689
2690 make_generic ("shiftl", GFC_ISYM_SHIFTL, GFC_STD_F2008);
2691
2692 add_sym_2 ("shiftr", GFC_ISYM_SHIFTR, CLASS_ELEMENTAL, ACTUAL_NO,
2693 BT_INTEGER, di, GFC_STD_F2008,
2694 gfc_check_shift, gfc_simplify_shiftr, gfc_resolve_shift,
2695 i, BT_INTEGER, di, REQUIRED,
2696 sh, BT_INTEGER, di, REQUIRED);
2697
2698 make_generic ("shiftr", GFC_ISYM_SHIFTR, GFC_STD_F2008);
2699
2700 add_sym_2 ("sign", GFC_ISYM_SIGN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
2701 gfc_check_sign, gfc_simplify_sign, gfc_resolve_sign,
2702 a, BT_REAL, dr, REQUIRED, b, BT_REAL, dr, REQUIRED);
2703
2704 add_sym_2 ("isign", GFC_ISYM_SIGN, CLASS_ELEMENTAL, ACTUAL_YES, BT_INTEGER, di, GFC_STD_F77,
2705 NULL, gfc_simplify_sign, gfc_resolve_sign,
2706 a, BT_INTEGER, di, REQUIRED, b, BT_INTEGER, di, REQUIRED);
2707
2708 add_sym_2 ("dsign", GFC_ISYM_SIGN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
2709 gfc_check_x_yd, gfc_simplify_sign, gfc_resolve_sign,
2710 a, BT_REAL, dd, REQUIRED, b, BT_REAL, dd, REQUIRED);
2711
2712 make_generic ("sign", GFC_ISYM_SIGN, GFC_STD_F77);
2713
2714 add_sym_2 ("signal", GFC_ISYM_SIGNAL, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
2715 di, GFC_STD_GNU, gfc_check_signal, NULL, gfc_resolve_signal,
2716 num, BT_INTEGER, di, REQUIRED, han, BT_VOID, 0, REQUIRED);
2717
2718 make_generic ("signal", GFC_ISYM_SIGNAL, GFC_STD_GNU);
2719
2720 add_sym_1 ("sin", GFC_ISYM_SIN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
2721 gfc_check_fn_rc, gfc_simplify_sin, gfc_resolve_sin,
2722 x, BT_REAL, dr, REQUIRED);
2723
2724 add_sym_1 ("dsin", GFC_ISYM_SIN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
2725 gfc_check_fn_d, gfc_simplify_sin, gfc_resolve_sin,
2726 x, BT_REAL, dd, REQUIRED);
2727
2728 add_sym_1 ("csin", GFC_ISYM_SIN, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dz, GFC_STD_F77,
2729 NULL, gfc_simplify_sin, gfc_resolve_sin,
2730 x, BT_COMPLEX, dz, REQUIRED);
2731
2732 add_sym_1 ("zsin", GFC_ISYM_SIN, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dd, GFC_STD_GNU,
2733 NULL, gfc_simplify_sin, gfc_resolve_sin,
2734 x, BT_COMPLEX, dd, REQUIRED);
2735
2736 make_alias ("cdsin", GFC_STD_GNU);
2737
2738 make_generic ("sin", GFC_ISYM_SIN, GFC_STD_F77);
2739
2740 add_sym_1 ("sinh", GFC_ISYM_SINH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
2741 gfc_check_fn_rc2008, gfc_simplify_sinh, gfc_resolve_sinh,
2742 x, BT_REAL, dr, REQUIRED);
2743
2744 add_sym_1 ("dsinh", GFC_ISYM_SINH,CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
2745 gfc_check_fn_d, gfc_simplify_sinh, gfc_resolve_sinh,
2746 x, BT_REAL, dd, REQUIRED);
2747
2748 make_generic ("sinh", GFC_ISYM_SINH, GFC_STD_F77);
2749
2750 add_sym_3 ("size", GFC_ISYM_SIZE, CLASS_INQUIRY, ACTUAL_NO,
2751 BT_INTEGER, di, GFC_STD_F95,
2752 gfc_check_size, gfc_simplify_size, gfc_resolve_size,
2753 ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
2754 kind, BT_INTEGER, di, OPTIONAL);
2755
2756 make_generic ("size", GFC_ISYM_SIZE, GFC_STD_F95);
2757
2758 /* Obtain the stride for a given dimensions; to be used only internally.
2759 "make_from_module" makes it inaccessible for external users. */
2760 add_sym_2 (GFC_PREFIX ("stride"), GFC_ISYM_STRIDE, CLASS_INQUIRY, ACTUAL_NO,
2761 BT_INTEGER, gfc_index_integer_kind, GFC_STD_GNU,
2762 NULL, NULL, gfc_resolve_stride,
2763 ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL);
2764 make_from_module();
2765
2766 add_sym_1 ("sizeof", GFC_ISYM_SIZEOF, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, ii,
2767 GFC_STD_GNU, gfc_check_sizeof, gfc_simplify_sizeof, NULL,
2768 x, BT_UNKNOWN, 0, REQUIRED);
2769
2770 make_generic ("sizeof", GFC_ISYM_SIZEOF, GFC_STD_GNU);
2771
2772 /* The following functions are part of ISO_C_BINDING. */
2773 add_sym_2 ("c_associated", GFC_ISYM_C_ASSOCIATED, CLASS_INQUIRY, ACTUAL_NO,
2774 BT_LOGICAL, dl, GFC_STD_F2003, gfc_check_c_associated, NULL, NULL,
2775 "C_PTR_1", BT_VOID, 0, REQUIRED,
2776 "C_PTR_2", BT_VOID, 0, OPTIONAL);
2777 make_from_module();
2778
2779 add_sym_1 ("c_loc", GFC_ISYM_C_LOC, CLASS_INQUIRY, ACTUAL_NO,
2780 BT_VOID, 0, GFC_STD_F2003,
2781 gfc_check_c_loc, NULL, gfc_resolve_c_loc,
2782 x, BT_UNKNOWN, 0, REQUIRED);
2783 make_from_module();
2784
2785 add_sym_1 ("c_funloc", GFC_ISYM_C_FUNLOC, CLASS_INQUIRY, ACTUAL_NO,
2786 BT_VOID, 0, GFC_STD_F2003,
2787 gfc_check_c_funloc, NULL, gfc_resolve_c_funloc,
2788 x, BT_UNKNOWN, 0, REQUIRED);
2789 make_from_module();
2790
2791 add_sym_1 ("c_sizeof", GFC_ISYM_C_SIZEOF, CLASS_INQUIRY, ACTUAL_NO,
2792 BT_INTEGER, gfc_index_integer_kind, GFC_STD_F2008,
2793 gfc_check_c_sizeof, gfc_simplify_sizeof, NULL,
2794 x, BT_UNKNOWN, 0, REQUIRED);
2795 make_from_module();
2796
2797 /* COMPILER_OPTIONS and COMPILER_VERSION are part of ISO_FORTRAN_ENV. */
2798 add_sym_0 ("compiler_options", GFC_ISYM_COMPILER_OPTIONS, CLASS_INQUIRY,
2799 ACTUAL_NO, BT_CHARACTER, dc, GFC_STD_F2008,
2800 NULL, gfc_simplify_compiler_options, NULL);
2801 make_from_module();
2802
2803 add_sym_0 ("compiler_version", GFC_ISYM_COMPILER_VERSION, CLASS_INQUIRY,
2804 ACTUAL_NO, BT_CHARACTER, dc, GFC_STD_F2008,
2805 NULL, gfc_simplify_compiler_version, NULL);
2806 make_from_module();
2807
2808 add_sym_1 ("spacing", GFC_ISYM_SPACING, CLASS_ELEMENTAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2809 gfc_check_x, gfc_simplify_spacing, gfc_resolve_spacing,
2810 x, BT_REAL, dr, REQUIRED);
2811
2812 make_generic ("spacing", GFC_ISYM_SPACING, GFC_STD_F95);
2813
2814 add_sym_3 ("spread", GFC_ISYM_SPREAD, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2815 gfc_check_spread, gfc_simplify_spread, gfc_resolve_spread,
2816 src, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, REQUIRED,
2817 ncopies, BT_INTEGER, di, REQUIRED);
2818
2819 make_generic ("spread", GFC_ISYM_SPREAD, GFC_STD_F95);
2820
2821 add_sym_1 ("sqrt", GFC_ISYM_SQRT, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
2822 gfc_check_fn_rc, gfc_simplify_sqrt, gfc_resolve_sqrt,
2823 x, BT_REAL, dr, REQUIRED);
2824
2825 add_sym_1 ("dsqrt", GFC_ISYM_SQRT, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
2826 gfc_check_fn_d, gfc_simplify_sqrt, gfc_resolve_sqrt,
2827 x, BT_REAL, dd, REQUIRED);
2828
2829 add_sym_1 ("csqrt", GFC_ISYM_SQRT, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dz, GFC_STD_F77,
2830 NULL, gfc_simplify_sqrt, gfc_resolve_sqrt,
2831 x, BT_COMPLEX, dz, REQUIRED);
2832
2833 add_sym_1 ("zsqrt", GFC_ISYM_SQRT, CLASS_ELEMENTAL, ACTUAL_YES, BT_COMPLEX, dd, GFC_STD_GNU,
2834 NULL, gfc_simplify_sqrt, gfc_resolve_sqrt,
2835 x, BT_COMPLEX, dd, REQUIRED);
2836
2837 make_alias ("cdsqrt", GFC_STD_GNU);
2838
2839 make_generic ("sqrt", GFC_ISYM_SQRT, GFC_STD_F77);
2840
2841 add_sym_2_intent ("stat", GFC_ISYM_STAT, CLASS_IMPURE, ACTUAL_NO,
2842 BT_INTEGER, di, GFC_STD_GNU,
2843 gfc_check_stat, NULL, gfc_resolve_stat,
2844 nm, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
2845 vl, BT_INTEGER, di, REQUIRED, INTENT_OUT);
2846
2847 make_generic ("stat", GFC_ISYM_STAT, GFC_STD_GNU);
2848
2849 add_sym_2 ("storage_size", GFC_ISYM_STORAGE_SIZE, CLASS_INQUIRY, ACTUAL_NO,
2850 BT_INTEGER, di, GFC_STD_F2008,
2851 gfc_check_storage_size, gfc_simplify_storage_size,
2852 gfc_resolve_storage_size,
2853 a, BT_UNKNOWN, 0, REQUIRED,
2854 kind, BT_INTEGER, di, OPTIONAL);
2855
2856 add_sym_3red ("sum", GFC_ISYM_SUM, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2857 gfc_check_product_sum, gfc_simplify_sum, gfc_resolve_sum,
2858 ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
2859 msk, BT_LOGICAL, dl, OPTIONAL);
2860
2861 make_generic ("sum", GFC_ISYM_SUM, GFC_STD_F95);
2862
2863 add_sym_2 ("symlnk", GFC_ISYM_SYMLNK, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, di,
2864 GFC_STD_GNU, gfc_check_symlnk, NULL, gfc_resolve_symlnk,
2865 p1, BT_CHARACTER, dc, REQUIRED, p2, BT_CHARACTER, dc, REQUIRED);
2866
2867 make_generic ("symlnk", GFC_ISYM_SYMLNK, GFC_STD_GNU);
2868
2869 add_sym_1 ("system", GFC_ISYM_SYSTEM, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, di,
2870 GFC_STD_GNU, NULL, NULL, NULL,
2871 com, BT_CHARACTER, dc, REQUIRED);
2872
2873 make_generic ("system", GFC_ISYM_SYSTEM, GFC_STD_GNU);
2874
2875 add_sym_1 ("tan", GFC_ISYM_TAN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
2876 gfc_check_fn_rc2008, gfc_simplify_tan, gfc_resolve_tan,
2877 x, BT_REAL, dr, REQUIRED);
2878
2879 add_sym_1 ("dtan", GFC_ISYM_TAN, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
2880 gfc_check_fn_d, gfc_simplify_tan, gfc_resolve_tan,
2881 x, BT_REAL, dd, REQUIRED);
2882
2883 make_generic ("tan", GFC_ISYM_TAN, GFC_STD_F77);
2884
2885 add_sym_1 ("tanh", GFC_ISYM_TANH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dr, GFC_STD_F77,
2886 gfc_check_fn_rc2008, gfc_simplify_tanh, gfc_resolve_tanh,
2887 x, BT_REAL, dr, REQUIRED);
2888
2889 add_sym_1 ("dtanh", GFC_ISYM_TANH, CLASS_ELEMENTAL, ACTUAL_YES, BT_REAL, dd, GFC_STD_F77,
2890 gfc_check_fn_d, gfc_simplify_tanh, gfc_resolve_tanh,
2891 x, BT_REAL, dd, REQUIRED);
2892
2893 make_generic ("tanh", GFC_ISYM_TANH, GFC_STD_F77);
2894
2895 add_sym_2 ("this_image", GFC_ISYM_THIS_IMAGE, CLASS_INQUIRY, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F2008,
2896 gfc_check_this_image, gfc_simplify_this_image, gfc_resolve_this_image,
2897 ca, BT_REAL, dr, OPTIONAL, dm, BT_INTEGER, ii, OPTIONAL);
2898
2899 add_sym_0 ("time", GFC_ISYM_TIME, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
2900 di, GFC_STD_GNU, NULL, NULL, gfc_resolve_time);
2901
2902 make_generic ("time", GFC_ISYM_TIME, GFC_STD_GNU);
2903
2904 add_sym_0 ("time8", GFC_ISYM_TIME8, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
2905 di, GFC_STD_GNU, NULL, NULL, gfc_resolve_time8);
2906
2907 make_generic ("time8", GFC_ISYM_TIME8, GFC_STD_GNU);
2908
2909 add_sym_1 ("tiny", GFC_ISYM_TINY, CLASS_INQUIRY, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2910 gfc_check_x, gfc_simplify_tiny, NULL,
2911 x, BT_REAL, dr, REQUIRED);
2912
2913 make_generic ("tiny", GFC_ISYM_TINY, GFC_STD_F95);
2914
2915 add_sym_1 ("trailz", GFC_ISYM_TRAILZ, CLASS_ELEMENTAL, ACTUAL_NO,
2916 BT_INTEGER, di, GFC_STD_F2008,
2917 gfc_check_i, gfc_simplify_trailz, NULL,
2918 i, BT_INTEGER, di, REQUIRED);
2919
2920 make_generic ("trailz", GFC_ISYM_TRAILZ, GFC_STD_F2008);
2921
2922 add_sym_3 ("transfer", GFC_ISYM_TRANSFER, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2923 gfc_check_transfer, gfc_simplify_transfer, gfc_resolve_transfer,
2924 src, BT_REAL, dr, REQUIRED, mo, BT_REAL, dr, REQUIRED,
2925 sz, BT_INTEGER, di, OPTIONAL);
2926
2927 make_generic ("transfer", GFC_ISYM_TRANSFER, GFC_STD_F95);
2928
2929 add_sym_1 ("transpose", GFC_ISYM_TRANSPOSE, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2930 gfc_check_transpose, gfc_simplify_transpose, gfc_resolve_transpose,
2931 m, BT_REAL, dr, REQUIRED);
2932
2933 make_generic ("transpose", GFC_ISYM_TRANSPOSE, GFC_STD_F95);
2934
2935 add_sym_1 ("trim", GFC_ISYM_TRIM, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_CHARACTER, dc, GFC_STD_F95,
2936 gfc_check_trim, gfc_simplify_trim, gfc_resolve_trim,
2937 stg, BT_CHARACTER, dc, REQUIRED);
2938
2939 make_generic ("trim", GFC_ISYM_TRIM, GFC_STD_F95);
2940
2941 add_sym_1 ("ttynam", GFC_ISYM_TTYNAM, CLASS_IMPURE, ACTUAL_NO, BT_CHARACTER,
2942 0, GFC_STD_GNU, gfc_check_ttynam, NULL, gfc_resolve_ttynam,
2943 ut, BT_INTEGER, di, REQUIRED);
2944
2945 make_generic ("ttynam", GFC_ISYM_TTYNAM, GFC_STD_GNU);
2946
2947 add_sym_3 ("ubound", GFC_ISYM_UBOUND, CLASS_INQUIRY, ACTUAL_NO,
2948 BT_INTEGER, di, GFC_STD_F95,
2949 gfc_check_ubound, gfc_simplify_ubound, gfc_resolve_ubound,
2950 ar, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
2951 kind, BT_INTEGER, di, OPTIONAL);
2952
2953 make_generic ("ubound", GFC_ISYM_UBOUND, GFC_STD_F95);
2954
2955 add_sym_3 ("ucobound", GFC_ISYM_UCOBOUND, CLASS_INQUIRY, ACTUAL_NO,
2956 BT_INTEGER, di, GFC_STD_F2008,
2957 gfc_check_ucobound, gfc_simplify_ucobound, gfc_resolve_ucobound,
2958 ca, BT_REAL, dr, REQUIRED, dm, BT_INTEGER, ii, OPTIONAL,
2959 kind, BT_INTEGER, di, OPTIONAL);
2960
2961 make_generic ("ucobound", GFC_ISYM_UCOBOUND, GFC_STD_F2008);
2962
2963 /* g77 compatibility for UMASK. */
2964 add_sym_1 ("umask", GFC_ISYM_UMASK, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, di,
2965 GFC_STD_GNU, gfc_check_umask, NULL, gfc_resolve_umask,
2966 msk, BT_INTEGER, di, REQUIRED);
2967
2968 make_generic ("umask", GFC_ISYM_UMASK, GFC_STD_GNU);
2969
2970 /* g77 compatibility for UNLINK. */
2971 add_sym_1 ("unlink", GFC_ISYM_UNLINK, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER,
2972 di, GFC_STD_GNU, gfc_check_unlink, NULL, gfc_resolve_unlink,
2973 "path", BT_CHARACTER, dc, REQUIRED);
2974
2975 make_generic ("unlink", GFC_ISYM_UNLINK, GFC_STD_GNU);
2976
2977 add_sym_3 ("unpack", GFC_ISYM_UNPACK, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_REAL, dr, GFC_STD_F95,
2978 gfc_check_unpack, gfc_simplify_unpack, gfc_resolve_unpack,
2979 v, BT_REAL, dr, REQUIRED, msk, BT_LOGICAL, dl, REQUIRED,
2980 f, BT_REAL, dr, REQUIRED);
2981
2982 make_generic ("unpack", GFC_ISYM_UNPACK, GFC_STD_F95);
2983
2984 add_sym_4 ("verify", GFC_ISYM_VERIFY, CLASS_ELEMENTAL, ACTUAL_NO,
2985 BT_INTEGER, di, GFC_STD_F95,
2986 gfc_check_verify, gfc_simplify_verify, gfc_resolve_verify,
2987 stg, BT_CHARACTER, dc, REQUIRED, set, BT_CHARACTER, dc, REQUIRED,
2988 bck, BT_LOGICAL, dl, OPTIONAL, kind, BT_INTEGER, di, OPTIONAL);
2989
2990 make_generic ("verify", GFC_ISYM_VERIFY, GFC_STD_F95);
2991
2992 add_sym_1 ("loc", GFC_ISYM_LOC, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, ii,
2993 GFC_STD_GNU, gfc_check_loc, NULL, gfc_resolve_loc,
2994 x, BT_UNKNOWN, 0, REQUIRED);
2995
2996 make_generic ("loc", GFC_ISYM_LOC, GFC_STD_GNU);
2997
2998 /* The following function is internally used for coarray libray functions.
2999 "make_from_module" makes it inaccessible for external users. */
3000 add_sym_1 (GFC_PREFIX ("caf_get"), GFC_ISYM_CAF_GET, CLASS_IMPURE, ACTUAL_NO,
3001 BT_REAL, dr, GFC_STD_GNU, NULL, NULL, NULL,
3002 x, BT_REAL, dr, REQUIRED);
3003 make_from_module();
3004 }
3005
3006
3007 /* Add intrinsic subroutines. */
3008
3009 static void
3010 add_subroutines (void)
3011 {
3012 /* Argument names as in the standard (to be used as argument keywords). */
3013 const char
3014 *a = "a", *h = "harvest", *dt = "date", *vl = "values", *pt = "put",
3015 *c = "count", *tm = "time", *tp = "topos", *gt = "get",
3016 *t = "to", *zn = "zone", *fp = "frompos", *cm = "count_max",
3017 *f = "from", *sz = "size", *ln = "len", *cr = "count_rate",
3018 *com = "command", *length = "length", *st = "status",
3019 *val = "value", *num = "number", *name = "name",
3020 *trim_name = "trim_name", *ut = "unit", *han = "handler",
3021 *sec = "seconds", *res = "result", *of = "offset", *md = "mode",
3022 *whence = "whence", *pos = "pos", *ptr = "ptr", *p1 = "path1",
3023 *p2 = "path2", *msk = "mask", *old = "old", *result_image = "result_image",
3024 *stat = "stat", *errmsg = "errmsg";
3025
3026 int di, dr, dc, dl, ii;
3027
3028 di = gfc_default_integer_kind;
3029 dr = gfc_default_real_kind;
3030 dc = gfc_default_character_kind;
3031 dl = gfc_default_logical_kind;
3032 ii = gfc_index_integer_kind;
3033
3034 add_sym_0s ("abort", GFC_ISYM_ABORT, GFC_STD_GNU, NULL);
3035
3036 make_noreturn();
3037
3038 add_sym_2s ("atomic_define", GFC_ISYM_ATOMIC_DEF, CLASS_ATOMIC,
3039 BT_UNKNOWN, 0, GFC_STD_F2008,
3040 gfc_check_atomic_def, NULL, gfc_resolve_atomic_def,
3041 "atom", BT_INTEGER, di, REQUIRED, INTENT_OUT,
3042 "value", BT_INTEGER, di, REQUIRED, INTENT_IN);
3043
3044 add_sym_2s ("atomic_ref", GFC_ISYM_ATOMIC_REF, CLASS_ATOMIC,
3045 BT_UNKNOWN, 0, GFC_STD_F2008,
3046 gfc_check_atomic_ref, NULL, gfc_resolve_atomic_ref,
3047 "value", BT_INTEGER, di, REQUIRED, INTENT_OUT,
3048 "atom", BT_INTEGER, di, REQUIRED, INTENT_IN);
3049
3050 add_sym_0s ("backtrace", GFC_ISYM_BACKTRACE, GFC_STD_GNU, NULL);
3051
3052 add_sym_1s ("cpu_time", GFC_ISYM_CPU_TIME, CLASS_IMPURE, BT_UNKNOWN, 0,
3053 GFC_STD_F95, gfc_check_cpu_time, NULL, gfc_resolve_cpu_time,
3054 tm, BT_REAL, dr, REQUIRED, INTENT_OUT);
3055
3056 /* More G77 compatibility garbage. */
3057 add_sym_2s ("ctime", GFC_ISYM_CTIME, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3058 gfc_check_ctime_sub, NULL, gfc_resolve_ctime_sub,
3059 tm, BT_INTEGER, di, REQUIRED, INTENT_IN,
3060 res, BT_CHARACTER, dc, REQUIRED, INTENT_OUT);
3061
3062 add_sym_1s ("idate", GFC_ISYM_IDATE, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3063 gfc_check_itime_idate, NULL, gfc_resolve_idate,
3064 vl, BT_INTEGER, 4, REQUIRED, INTENT_OUT);
3065
3066 add_sym_1s ("itime", GFC_ISYM_ITIME, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3067 gfc_check_itime_idate, NULL, gfc_resolve_itime,
3068 vl, BT_INTEGER, 4, REQUIRED, INTENT_OUT);
3069
3070 add_sym_2s ("ltime", GFC_ISYM_LTIME, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3071 gfc_check_ltime_gmtime, NULL, gfc_resolve_ltime,
3072 tm, BT_INTEGER, di, REQUIRED, INTENT_IN,
3073 vl, BT_INTEGER, di, REQUIRED, INTENT_OUT);
3074
3075 add_sym_2s ("gmtime", GFC_ISYM_GMTIME, CLASS_IMPURE, BT_UNKNOWN, 0,
3076 GFC_STD_GNU, gfc_check_ltime_gmtime, NULL, gfc_resolve_gmtime,
3077 tm, BT_INTEGER, di, REQUIRED, INTENT_IN,
3078 vl, BT_INTEGER, di, REQUIRED, INTENT_OUT);
3079
3080 add_sym_1s ("second", GFC_ISYM_SECOND, CLASS_IMPURE, BT_UNKNOWN, 0,
3081 GFC_STD_GNU, gfc_check_second_sub, NULL, gfc_resolve_second_sub,
3082 tm, BT_REAL, dr, REQUIRED, INTENT_OUT);
3083
3084 add_sym_2s ("chdir", GFC_ISYM_CHDIR, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3085 gfc_check_chdir_sub, NULL, gfc_resolve_chdir_sub,
3086 name, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3087 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3088
3089 add_sym_3s ("chmod", GFC_ISYM_CHMOD, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3090 gfc_check_chmod_sub, NULL, gfc_resolve_chmod_sub,
3091 name, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3092 md, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3093 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3094
3095 add_sym_4s ("date_and_time", GFC_ISYM_DATE_AND_TIME, CLASS_IMPURE, BT_UNKNOWN,
3096 0, GFC_STD_F95, gfc_check_date_and_time, NULL, NULL,
3097 dt, BT_CHARACTER, dc, OPTIONAL, INTENT_OUT,
3098 tm, BT_CHARACTER, dc, OPTIONAL, INTENT_OUT,
3099 zn, BT_CHARACTER, dc, OPTIONAL, INTENT_OUT,
3100 vl, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3101
3102 /* More G77 compatibility garbage. */
3103 add_sym_2s ("etime", GFC_ISYM_ETIME, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3104 gfc_check_dtime_etime_sub, NULL, gfc_resolve_etime_sub,
3105 vl, BT_REAL, 4, REQUIRED, INTENT_OUT,
3106 tm, BT_REAL, 4, REQUIRED, INTENT_OUT);
3107
3108 add_sym_2s ("dtime", GFC_ISYM_DTIME, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3109 gfc_check_dtime_etime_sub, NULL, gfc_resolve_dtime_sub,
3110 vl, BT_REAL, 4, REQUIRED, INTENT_OUT,
3111 tm, BT_REAL, 4, REQUIRED, INTENT_OUT);
3112
3113 add_sym_5s ("execute_command_line", GFC_ISYM_EXECUTE_COMMAND_LINE,
3114 CLASS_IMPURE , BT_UNKNOWN, 0, GFC_STD_F2008,
3115 NULL, NULL, gfc_resolve_execute_command_line,
3116 "command", BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3117 "wait", BT_LOGICAL, dl, OPTIONAL, INTENT_IN,
3118 "exitstat", BT_INTEGER, di, OPTIONAL, INTENT_INOUT,
3119 "cmdstat", BT_INTEGER, di, OPTIONAL, INTENT_OUT,
3120 "cmdmsg", BT_CHARACTER, dc, OPTIONAL, INTENT_INOUT);
3121
3122 add_sym_1s ("fdate", GFC_ISYM_FDATE, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3123 gfc_check_fdate_sub, NULL, gfc_resolve_fdate_sub,
3124 dt, BT_CHARACTER, dc, REQUIRED, INTENT_OUT);
3125
3126 add_sym_1s ("gerror", GFC_ISYM_GERROR, CLASS_IMPURE, BT_UNKNOWN,
3127 0, GFC_STD_GNU, gfc_check_gerror, NULL, gfc_resolve_gerror,
3128 res, BT_CHARACTER, dc, REQUIRED, INTENT_OUT);
3129
3130 add_sym_2s ("getcwd", GFC_ISYM_GETCWD, CLASS_IMPURE, BT_UNKNOWN, 0,
3131 GFC_STD_GNU, gfc_check_getcwd_sub, NULL, gfc_resolve_getcwd_sub,
3132 c, BT_CHARACTER, dc, REQUIRED, INTENT_OUT,
3133 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3134
3135 add_sym_2s ("getenv", GFC_ISYM_GETENV, CLASS_IMPURE, BT_UNKNOWN,
3136 0, GFC_STD_GNU, NULL, NULL, NULL,
3137 name, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3138 val, BT_CHARACTER, dc, REQUIRED, INTENT_OUT);
3139
3140 add_sym_2s ("getarg", GFC_ISYM_GETARG, CLASS_IMPURE, BT_UNKNOWN,
3141 0, GFC_STD_GNU, gfc_check_getarg, NULL, gfc_resolve_getarg,
3142 pos, BT_INTEGER, di, REQUIRED, INTENT_IN,
3143 val, BT_CHARACTER, dc, REQUIRED, INTENT_OUT);
3144
3145 add_sym_1s ("getlog", GFC_ISYM_GETLOG, CLASS_IMPURE, BT_UNKNOWN,
3146 0, GFC_STD_GNU, gfc_check_getlog, NULL, gfc_resolve_getlog,
3147 c, BT_CHARACTER, dc, REQUIRED, INTENT_OUT);
3148
3149 /* F2003 commandline routines. */
3150
3151 add_sym_3s ("get_command", GFC_ISYM_GET_COMMAND, CLASS_IMPURE,
3152 BT_UNKNOWN, 0, GFC_STD_F2003,
3153 NULL, NULL, gfc_resolve_get_command,
3154 com, BT_CHARACTER, dc, OPTIONAL, INTENT_OUT,
3155 length, BT_INTEGER, di, OPTIONAL, INTENT_OUT,
3156 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3157
3158 add_sym_4s ("get_command_argument", GFC_ISYM_GET_COMMAND_ARGUMENT,
3159 CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_F2003, NULL, NULL,
3160 gfc_resolve_get_command_argument,
3161 num, BT_INTEGER, di, REQUIRED, INTENT_IN,
3162 val, BT_CHARACTER, dc, OPTIONAL, INTENT_OUT,
3163 length, BT_INTEGER, di, OPTIONAL, INTENT_OUT,
3164 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3165
3166 /* F2003 subroutine to get environment variables. */
3167
3168 add_sym_5s ("get_environment_variable", GFC_ISYM_GET_ENVIRONMENT_VARIABLE,
3169 CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_F2003,
3170 NULL, NULL, gfc_resolve_get_environment_variable,
3171 name, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3172 val, BT_CHARACTER, dc, OPTIONAL, INTENT_OUT,
3173 length, BT_INTEGER, di, OPTIONAL, INTENT_OUT,
3174 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT,
3175 trim_name, BT_LOGICAL, dl, OPTIONAL, INTENT_IN);
3176
3177 add_sym_2s ("move_alloc", GFC_ISYM_MOVE_ALLOC, CLASS_PURE, BT_UNKNOWN, 0,
3178 GFC_STD_F2003,
3179 gfc_check_move_alloc, NULL, NULL,
3180 f, BT_UNKNOWN, 0, REQUIRED, INTENT_INOUT,
3181 t, BT_UNKNOWN, 0, REQUIRED, INTENT_OUT);
3182
3183 add_sym_5s ("mvbits", GFC_ISYM_MVBITS, CLASS_ELEMENTAL, BT_UNKNOWN, 0,
3184 GFC_STD_F95, gfc_check_mvbits, gfc_simplify_mvbits,
3185 gfc_resolve_mvbits,
3186 f, BT_INTEGER, di, REQUIRED, INTENT_IN,
3187 fp, BT_INTEGER, di, REQUIRED, INTENT_IN,
3188 ln, BT_INTEGER, di, REQUIRED, INTENT_IN,
3189 t, BT_INTEGER, di, REQUIRED, INTENT_INOUT,
3190 tp, BT_INTEGER, di, REQUIRED, INTENT_IN);
3191
3192 add_sym_1s ("random_number", GFC_ISYM_RANDOM_NUMBER, CLASS_IMPURE,
3193 BT_UNKNOWN, 0, GFC_STD_F95,
3194 gfc_check_random_number, NULL, gfc_resolve_random_number,
3195 h, BT_REAL, dr, REQUIRED, INTENT_OUT);
3196
3197 add_sym_3s ("random_seed", GFC_ISYM_RANDOM_SEED, CLASS_IMPURE,
3198 BT_UNKNOWN, 0, GFC_STD_F95,
3199 gfc_check_random_seed, NULL, gfc_resolve_random_seed,
3200 sz, BT_INTEGER, di, OPTIONAL, INTENT_OUT,
3201 pt, BT_INTEGER, di, OPTIONAL, INTENT_IN,
3202 gt, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3203
3204 /* The following subroutines are part of ISO_C_BINDING. */
3205
3206 add_sym_3s ("c_f_pointer", GFC_ISYM_C_F_POINTER, CLASS_IMPURE, BT_UNKNOWN, 0,
3207 GFC_STD_F2003, gfc_check_c_f_pointer, NULL, NULL,
3208 "cptr", BT_VOID, 0, REQUIRED, INTENT_IN,
3209 "fptr", BT_UNKNOWN, 0, REQUIRED, INTENT_OUT,
3210 "shape", BT_INTEGER, di, OPTIONAL, INTENT_IN);
3211 make_from_module();
3212
3213 add_sym_2s ("c_f_procpointer", GFC_ISYM_C_F_PROCPOINTER, CLASS_IMPURE,
3214 BT_UNKNOWN, 0, GFC_STD_F2003, gfc_check_c_f_procpointer,
3215 NULL, NULL,
3216 "cptr", BT_VOID, 0, REQUIRED, INTENT_IN,
3217 "fptr", BT_UNKNOWN, 0, REQUIRED, INTENT_OUT);
3218 make_from_module();
3219
3220 /* Coarray collectives. */
3221 add_sym_4s ("co_max", GFC_ISYM_CO_MAX, CLASS_IMPURE,
3222 BT_UNKNOWN, 0, GFC_STD_F2008_TS,
3223 gfc_check_co_minmax, NULL, NULL,
3224 a, BT_REAL, dr, REQUIRED, INTENT_INOUT,
3225 result_image, BT_INTEGER, di, OPTIONAL, INTENT_IN,
3226 stat, BT_INTEGER, di, OPTIONAL, INTENT_OUT,
3227 errmsg, BT_CHARACTER, dc, OPTIONAL, INTENT_OUT);
3228
3229 add_sym_4s ("co_min", GFC_ISYM_CO_MIN, CLASS_IMPURE,
3230 BT_UNKNOWN, 0, GFC_STD_F2008_TS,
3231 gfc_check_co_minmax, NULL, NULL,
3232 a, BT_REAL, dr, REQUIRED, INTENT_INOUT,
3233 result_image, BT_INTEGER, di, OPTIONAL, INTENT_IN,
3234 stat, BT_INTEGER, di, OPTIONAL, INTENT_OUT,
3235 errmsg, BT_CHARACTER, dc, OPTIONAL, INTENT_OUT);
3236
3237 add_sym_4s ("co_sum", GFC_ISYM_CO_SUM, CLASS_IMPURE,
3238 BT_UNKNOWN, 0, GFC_STD_F2008_TS,
3239 gfc_check_co_sum, NULL, NULL,
3240 a, BT_REAL, dr, REQUIRED, INTENT_INOUT,
3241 result_image, BT_INTEGER, di, OPTIONAL, INTENT_IN,
3242 stat, BT_INTEGER, di, OPTIONAL, INTENT_OUT,
3243 errmsg, BT_CHARACTER, dc, OPTIONAL, INTENT_OUT);
3244
3245 /* The following subroutine is internally used for coarray libray functions.
3246 "make_from_module" makes it inaccessible for external users. */
3247 add_sym_2s (GFC_PREFIX ("caf_send"), GFC_ISYM_CAF_SEND, CLASS_IMPURE,
3248 BT_UNKNOWN, 0, GFC_STD_GNU, NULL, NULL, NULL,
3249 "x", BT_REAL, dr, REQUIRED, INTENT_OUT,
3250 "y", BT_REAL, dr, REQUIRED, INTENT_IN);
3251 make_from_module();
3252
3253
3254 /* More G77 compatibility garbage. */
3255 add_sym_3s ("alarm", GFC_ISYM_ALARM, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3256 gfc_check_alarm_sub, NULL, gfc_resolve_alarm_sub,
3257 sec, BT_INTEGER, di, REQUIRED, INTENT_IN,
3258 han, BT_UNKNOWN, 0, REQUIRED, INTENT_IN,
3259 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3260
3261 add_sym_1s ("srand", GFC_ISYM_SRAND, CLASS_IMPURE, BT_UNKNOWN,
3262 di, GFC_STD_GNU, gfc_check_srand, NULL, gfc_resolve_srand,
3263 "seed", BT_INTEGER, 4, REQUIRED, INTENT_IN);
3264
3265 add_sym_1s ("exit", GFC_ISYM_EXIT, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3266 gfc_check_exit, NULL, gfc_resolve_exit,
3267 st, BT_INTEGER, di, OPTIONAL, INTENT_IN);
3268
3269 make_noreturn();
3270
3271 add_sym_3s ("fgetc", GFC_ISYM_FGETC, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3272 gfc_check_fgetputc_sub, NULL, gfc_resolve_fgetc_sub,
3273 ut, BT_INTEGER, di, REQUIRED, INTENT_IN,
3274 c, BT_CHARACTER, dc, REQUIRED, INTENT_OUT,
3275 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3276
3277 add_sym_2s ("fget", GFC_ISYM_FGET, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3278 gfc_check_fgetput_sub, NULL, gfc_resolve_fget_sub,
3279 c, BT_CHARACTER, dc, REQUIRED, INTENT_OUT,
3280 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3281
3282 add_sym_1s ("flush", GFC_ISYM_FLUSH, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3283 gfc_check_flush, NULL, gfc_resolve_flush,
3284 ut, BT_INTEGER, di, OPTIONAL, INTENT_IN);
3285
3286 add_sym_3s ("fputc", GFC_ISYM_FPUTC, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3287 gfc_check_fgetputc_sub, NULL, gfc_resolve_fputc_sub,
3288 ut, BT_INTEGER, di, REQUIRED, INTENT_IN,
3289 c, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3290 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3291
3292 add_sym_2s ("fput", GFC_ISYM_FPUT, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3293 gfc_check_fgetput_sub, NULL, gfc_resolve_fput_sub,
3294 c, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3295 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3296
3297 add_sym_1s ("free", GFC_ISYM_FREE, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3298 gfc_check_free, NULL, gfc_resolve_free,
3299 ptr, BT_INTEGER, ii, REQUIRED, INTENT_INOUT);
3300
3301 add_sym_4s ("fseek", GFC_ISYM_FSEEK, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3302 gfc_check_fseek_sub, NULL, gfc_resolve_fseek_sub,
3303 ut, BT_INTEGER, di, REQUIRED, INTENT_IN,
3304 of, BT_INTEGER, di, REQUIRED, INTENT_IN,
3305 whence, BT_INTEGER, di, REQUIRED, INTENT_IN,
3306 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3307
3308 add_sym_2s ("ftell", GFC_ISYM_FTELL, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3309 gfc_check_ftell_sub, NULL, gfc_resolve_ftell_sub,
3310 ut, BT_INTEGER, di, REQUIRED, INTENT_IN,
3311 of, BT_INTEGER, ii, REQUIRED, INTENT_OUT);
3312
3313 add_sym_2s ("hostnm", GFC_ISYM_HOSTNM, CLASS_IMPURE, BT_UNKNOWN, 0,
3314 GFC_STD_GNU, gfc_check_hostnm_sub, NULL, gfc_resolve_hostnm_sub,
3315 c, BT_CHARACTER, dc, REQUIRED, INTENT_OUT,
3316 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3317
3318 add_sym_3s ("kill", GFC_ISYM_KILL, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3319 gfc_check_kill_sub, NULL, gfc_resolve_kill_sub,
3320 c, BT_INTEGER, di, REQUIRED, INTENT_IN,
3321 val, BT_INTEGER, di, REQUIRED, INTENT_IN,
3322 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3323
3324 add_sym_3s ("link", GFC_ISYM_LINK, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3325 gfc_check_link_sub, NULL, gfc_resolve_link_sub,
3326 p1, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3327 p2, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3328 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3329
3330 add_sym_1s ("perror", GFC_ISYM_PERROR, CLASS_IMPURE, BT_UNKNOWN,
3331 0, GFC_STD_GNU, gfc_check_perror, NULL, gfc_resolve_perror,
3332 "string", BT_CHARACTER, dc, REQUIRED, INTENT_IN);
3333
3334 add_sym_3s ("rename", GFC_ISYM_RENAME, CLASS_IMPURE, BT_UNKNOWN, 0,
3335 GFC_STD_GNU, gfc_check_rename_sub, NULL, gfc_resolve_rename_sub,
3336 p1, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3337 p2, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3338 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3339
3340 add_sym_1s ("sleep", GFC_ISYM_SLEEP, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3341 gfc_check_sleep_sub, NULL, gfc_resolve_sleep_sub,
3342 sec, BT_INTEGER, di, REQUIRED, INTENT_IN);
3343
3344 add_sym_3s ("fstat", GFC_ISYM_FSTAT, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3345 gfc_check_fstat_sub, NULL, gfc_resolve_fstat_sub,
3346 ut, BT_INTEGER, di, REQUIRED, INTENT_IN,
3347 vl, BT_INTEGER, di, REQUIRED, INTENT_OUT,
3348 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3349
3350 add_sym_3s ("lstat", GFC_ISYM_LSTAT, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3351 gfc_check_stat_sub, NULL, gfc_resolve_lstat_sub,
3352 name, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3353 vl, BT_INTEGER, di, REQUIRED, INTENT_OUT,
3354 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3355
3356 add_sym_3s ("stat", GFC_ISYM_STAT, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3357 gfc_check_stat_sub, NULL, gfc_resolve_stat_sub,
3358 name, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3359 vl, BT_INTEGER, di, REQUIRED, INTENT_OUT,
3360 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3361
3362 add_sym_3s ("signal", GFC_ISYM_SIGNAL, CLASS_IMPURE, BT_UNKNOWN, 0,
3363 GFC_STD_GNU, gfc_check_signal_sub, NULL, gfc_resolve_signal_sub,
3364 num, BT_INTEGER, di, REQUIRED, INTENT_IN,
3365 han, BT_UNKNOWN, 0, REQUIRED, INTENT_IN,
3366 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3367
3368 add_sym_3s ("symlnk", GFC_ISYM_SYMLINK, CLASS_IMPURE, BT_UNKNOWN, 0,
3369 GFC_STD_GNU, gfc_check_symlnk_sub, NULL, gfc_resolve_symlnk_sub,
3370 p1, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3371 p2, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3372 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3373
3374 add_sym_2s ("system", GFC_ISYM_SYSTEM, CLASS_IMPURE, BT_UNKNOWN,
3375 0, GFC_STD_GNU, NULL, NULL, gfc_resolve_system_sub,
3376 com, BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3377 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3378
3379 add_sym_3s ("system_clock", GFC_ISYM_SYSTEM_CLOCK, CLASS_IMPURE,
3380 BT_UNKNOWN, 0, GFC_STD_F95,
3381 gfc_check_system_clock, NULL, gfc_resolve_system_clock,
3382 c, BT_INTEGER, di, OPTIONAL, INTENT_OUT,
3383 cr, BT_INTEGER, di, OPTIONAL, INTENT_OUT,
3384 cm, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3385
3386 add_sym_2s ("ttynam", GFC_ISYM_TTYNAM, CLASS_IMPURE, BT_UNKNOWN, 0,
3387 GFC_STD_GNU, gfc_check_ttynam_sub, NULL, gfc_resolve_ttynam_sub,
3388 ut, BT_INTEGER, di, REQUIRED, INTENT_IN,
3389 name, BT_CHARACTER, dc, REQUIRED, INTENT_OUT);
3390
3391 add_sym_2s ("umask", GFC_ISYM_UMASK, CLASS_IMPURE, BT_UNKNOWN, 0, GFC_STD_GNU,
3392 gfc_check_umask_sub, NULL, gfc_resolve_umask_sub,
3393 msk, BT_INTEGER, di, REQUIRED, INTENT_IN,
3394 old, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3395
3396 add_sym_2s ("unlink", GFC_ISYM_UNLINK, CLASS_IMPURE, BT_UNKNOWN, 0,
3397 GFC_STD_GNU, gfc_check_unlink_sub, NULL, gfc_resolve_unlink_sub,
3398 "path", BT_CHARACTER, dc, REQUIRED, INTENT_IN,
3399 st, BT_INTEGER, di, OPTIONAL, INTENT_OUT);
3400 }
3401
3402
3403 /* Add a function to the list of conversion symbols. */
3404
3405 static void
3406 add_conv (bt from_type, int from_kind, bt to_type, int to_kind, int standard)
3407 {
3408 gfc_typespec from, to;
3409 gfc_intrinsic_sym *sym;
3410
3411 if (sizing == SZ_CONVS)
3412 {
3413 nconv++;
3414 return;
3415 }
3416
3417 gfc_clear_ts (&from);
3418 from.type = from_type;
3419 from.kind = from_kind;
3420
3421 gfc_clear_ts (&to);
3422 to.type = to_type;
3423 to.kind = to_kind;
3424
3425 sym = conversion + nconv;
3426
3427 sym->name = conv_name (&from, &to);
3428 sym->lib_name = sym->name;
3429 sym->simplify.cc = gfc_convert_constant;
3430 sym->standard = standard;
3431 sym->elemental = 1;
3432 sym->pure = 1;
3433 sym->conversion = 1;
3434 sym->ts = to;
3435 sym->id = GFC_ISYM_CONVERSION;
3436
3437 nconv++;
3438 }
3439
3440
3441 /* Create gfc_intrinsic_sym nodes for all intrinsic conversion
3442 functions by looping over the kind tables. */
3443
3444 static void
3445 add_conversions (void)
3446 {
3447 int i, j;
3448
3449 /* Integer-Integer conversions. */
3450 for (i = 0; gfc_integer_kinds[i].kind != 0; i++)
3451 for (j = 0; gfc_integer_kinds[j].kind != 0; j++)
3452 {
3453 if (i == j)
3454 continue;
3455
3456 add_conv (BT_INTEGER, gfc_integer_kinds[i].kind,
3457 BT_INTEGER, gfc_integer_kinds[j].kind, GFC_STD_F77);
3458 }
3459
3460 /* Integer-Real/Complex conversions. */
3461 for (i = 0; gfc_integer_kinds[i].kind != 0; i++)
3462 for (j = 0; gfc_real_kinds[j].kind != 0; j++)
3463 {
3464 add_conv (BT_INTEGER, gfc_integer_kinds[i].kind,
3465 BT_REAL, gfc_real_kinds[j].kind, GFC_STD_F77);
3466
3467 add_conv (BT_REAL, gfc_real_kinds[j].kind,
3468 BT_INTEGER, gfc_integer_kinds[i].kind, GFC_STD_F77);
3469
3470 add_conv (BT_INTEGER, gfc_integer_kinds[i].kind,
3471 BT_COMPLEX, gfc_real_kinds[j].kind, GFC_STD_F77);
3472
3473 add_conv (BT_COMPLEX, gfc_real_kinds[j].kind,
3474 BT_INTEGER, gfc_integer_kinds[i].kind, GFC_STD_F77);
3475 }
3476
3477 if ((gfc_option.allow_std & GFC_STD_LEGACY) != 0)
3478 {
3479 /* Hollerith-Integer conversions. */
3480 for (i = 0; gfc_integer_kinds[i].kind != 0; i++)
3481 add_conv (BT_HOLLERITH, gfc_default_character_kind,
3482 BT_INTEGER, gfc_integer_kinds[i].kind, GFC_STD_LEGACY);
3483 /* Hollerith-Real conversions. */
3484 for (i = 0; gfc_real_kinds[i].kind != 0; i++)
3485 add_conv (BT_HOLLERITH, gfc_default_character_kind,
3486 BT_REAL, gfc_real_kinds[i].kind, GFC_STD_LEGACY);
3487 /* Hollerith-Complex conversions. */
3488 for (i = 0; gfc_real_kinds[i].kind != 0; i++)
3489 add_conv (BT_HOLLERITH, gfc_default_character_kind,
3490 BT_COMPLEX, gfc_real_kinds[i].kind, GFC_STD_LEGACY);
3491
3492 /* Hollerith-Character conversions. */
3493 add_conv (BT_HOLLERITH, gfc_default_character_kind, BT_CHARACTER,
3494 gfc_default_character_kind, GFC_STD_LEGACY);
3495
3496 /* Hollerith-Logical conversions. */
3497 for (i = 0; gfc_logical_kinds[i].kind != 0; i++)
3498 add_conv (BT_HOLLERITH, gfc_default_character_kind,
3499 BT_LOGICAL, gfc_logical_kinds[i].kind, GFC_STD_LEGACY);
3500 }
3501
3502 /* Real/Complex - Real/Complex conversions. */
3503 for (i = 0; gfc_real_kinds[i].kind != 0; i++)
3504 for (j = 0; gfc_real_kinds[j].kind != 0; j++)
3505 {
3506 if (i != j)
3507 {
3508 add_conv (BT_REAL, gfc_real_kinds[i].kind,
3509 BT_REAL, gfc_real_kinds[j].kind, GFC_STD_F77);
3510
3511 add_conv (BT_COMPLEX, gfc_real_kinds[i].kind,
3512 BT_COMPLEX, gfc_real_kinds[j].kind, GFC_STD_F77);
3513 }
3514
3515 add_conv (BT_REAL, gfc_real_kinds[i].kind,
3516 BT_COMPLEX, gfc_real_kinds[j].kind, GFC_STD_F77);
3517
3518 add_conv (BT_COMPLEX, gfc_real_kinds[i].kind,
3519 BT_REAL, gfc_real_kinds[j].kind, GFC_STD_F77);
3520 }
3521
3522 /* Logical/Logical kind conversion. */
3523 for (i = 0; gfc_logical_kinds[i].kind; i++)
3524 for (j = 0; gfc_logical_kinds[j].kind; j++)
3525 {
3526 if (i == j)
3527 continue;
3528
3529 add_conv (BT_LOGICAL, gfc_logical_kinds[i].kind,
3530 BT_LOGICAL, gfc_logical_kinds[j].kind, GFC_STD_F77);
3531 }
3532
3533 /* Integer-Logical and Logical-Integer conversions. */
3534 if ((gfc_option.allow_std & GFC_STD_LEGACY) != 0)
3535 for (i=0; gfc_integer_kinds[i].kind; i++)
3536 for (j=0; gfc_logical_kinds[j].kind; j++)
3537 {
3538 add_conv (BT_INTEGER, gfc_integer_kinds[i].kind,
3539 BT_LOGICAL, gfc_logical_kinds[j].kind, GFC_STD_LEGACY);
3540 add_conv (BT_LOGICAL, gfc_logical_kinds[j].kind,
3541 BT_INTEGER, gfc_integer_kinds[i].kind, GFC_STD_LEGACY);
3542 }
3543 }
3544
3545
3546 static void
3547 add_char_conversions (void)
3548 {
3549 int n, i, j;
3550
3551 /* Count possible conversions. */
3552 for (i = 0; gfc_character_kinds[i].kind != 0; i++)
3553 for (j = 0; gfc_character_kinds[j].kind != 0; j++)
3554 if (i != j)
3555 ncharconv++;
3556
3557 /* Allocate memory. */
3558 char_conversions = XCNEWVEC (gfc_intrinsic_sym, ncharconv);
3559
3560 /* Add the conversions themselves. */
3561 n = 0;
3562 for (i = 0; gfc_character_kinds[i].kind != 0; i++)
3563 for (j = 0; gfc_character_kinds[j].kind != 0; j++)
3564 {
3565 gfc_typespec from, to;
3566
3567 if (i == j)
3568 continue;
3569
3570 gfc_clear_ts (&from);
3571 from.type = BT_CHARACTER;
3572 from.kind = gfc_character_kinds[i].kind;
3573
3574 gfc_clear_ts (&to);
3575 to.type = BT_CHARACTER;
3576 to.kind = gfc_character_kinds[j].kind;
3577
3578 char_conversions[n].name = conv_name (&from, &to);
3579 char_conversions[n].lib_name = char_conversions[n].name;
3580 char_conversions[n].simplify.cc = gfc_convert_char_constant;
3581 char_conversions[n].standard = GFC_STD_F2003;
3582 char_conversions[n].elemental = 1;
3583 char_conversions[n].pure = 1;
3584 char_conversions[n].conversion = 0;
3585 char_conversions[n].ts = to;
3586 char_conversions[n].id = GFC_ISYM_CONVERSION;
3587
3588 n++;
3589 }
3590 }
3591
3592
3593 /* Initialize the table of intrinsics. */
3594 void
3595 gfc_intrinsic_init_1 (void)
3596 {
3597 nargs = nfunc = nsub = nconv = 0;
3598
3599 /* Create a namespace to hold the resolved intrinsic symbols. */
3600 gfc_intrinsic_namespace = gfc_get_namespace (NULL, 0);
3601
3602 sizing = SZ_FUNCS;
3603 add_functions ();
3604 sizing = SZ_SUBS;
3605 add_subroutines ();
3606 sizing = SZ_CONVS;
3607 add_conversions ();
3608
3609 functions = XCNEWVAR (struct gfc_intrinsic_sym,
3610 sizeof (gfc_intrinsic_sym) * (nfunc + nsub)
3611 + sizeof (gfc_intrinsic_arg) * nargs);
3612
3613 next_sym = functions;
3614 subroutines = functions + nfunc;
3615
3616 conversion = XCNEWVEC (gfc_intrinsic_sym, nconv);
3617
3618 next_arg = ((gfc_intrinsic_arg *) (subroutines + nsub)) - 1;
3619
3620 sizing = SZ_NOTHING;
3621 nconv = 0;
3622
3623 add_functions ();
3624 add_subroutines ();
3625 add_conversions ();
3626
3627 /* Character conversion intrinsics need to be treated separately. */
3628 add_char_conversions ();
3629 }
3630
3631
3632 void
3633 gfc_intrinsic_done_1 (void)
3634 {
3635 free (functions);
3636 free (conversion);
3637 free (char_conversions);
3638 gfc_free_namespace (gfc_intrinsic_namespace);
3639 }
3640
3641
3642 /******** Subroutines to check intrinsic interfaces ***********/
3643
3644 /* Given a formal argument list, remove any NULL arguments that may
3645 have been left behind by a sort against some formal argument list. */
3646
3647 static void
3648 remove_nullargs (gfc_actual_arglist **ap)
3649 {
3650 gfc_actual_arglist *head, *tail, *next;
3651
3652 tail = NULL;
3653
3654 for (head = *ap; head; head = next)
3655 {
3656 next = head->next;
3657
3658 if (head->expr == NULL && !head->label)
3659 {
3660 head->next = NULL;
3661 gfc_free_actual_arglist (head);
3662 }
3663 else
3664 {
3665 if (tail == NULL)
3666 *ap = head;
3667 else
3668 tail->next = head;
3669
3670 tail = head;
3671 tail->next = NULL;
3672 }
3673 }
3674
3675 if (tail == NULL)
3676 *ap = NULL;
3677 }
3678
3679
3680 /* Given an actual arglist and a formal arglist, sort the actual
3681 arglist so that its arguments are in a one-to-one correspondence
3682 with the format arglist. Arguments that are not present are given
3683 a blank gfc_actual_arglist structure. If something is obviously
3684 wrong (say, a missing required argument) we abort sorting and
3685 return false. */
3686
3687 static bool
3688 sort_actual (const char *name, gfc_actual_arglist **ap,
3689 gfc_intrinsic_arg *formal, locus *where)
3690 {
3691 gfc_actual_arglist *actual, *a;
3692 gfc_intrinsic_arg *f;
3693
3694 remove_nullargs (ap);
3695 actual = *ap;
3696
3697 for (f = formal; f; f = f->next)
3698 f->actual = NULL;
3699
3700 f = formal;
3701 a = actual;
3702
3703 if (f == NULL && a == NULL) /* No arguments */
3704 return true;
3705
3706 for (;;)
3707 { /* Put the nonkeyword arguments in a 1:1 correspondence */
3708 if (f == NULL)
3709 break;
3710 if (a == NULL)
3711 goto optional;
3712
3713 if (a->name != NULL)
3714 goto keywords;
3715
3716 f->actual = a;
3717
3718 f = f->next;
3719 a = a->next;
3720 }
3721
3722 if (a == NULL)
3723 goto do_sort;
3724
3725 gfc_error ("Too many arguments in call to '%s' at %L", name, where);
3726 return false;
3727
3728 keywords:
3729 /* Associate the remaining actual arguments, all of which have
3730 to be keyword arguments. */
3731 for (; a; a = a->next)
3732 {
3733 for (f = formal; f; f = f->next)
3734 if (strcmp (a->name, f->name) == 0)
3735 break;
3736
3737 if (f == NULL)
3738 {
3739 if (a->name[0] == '%')
3740 gfc_error ("The argument list functions %%VAL, %%LOC or %%REF "
3741 "are not allowed in this context at %L", where);
3742 else
3743 gfc_error ("Can't find keyword named '%s' in call to '%s' at %L",
3744 a->name, name, where);
3745 return false;
3746 }
3747
3748 if (f->actual != NULL)
3749 {
3750 gfc_error ("Argument '%s' appears twice in call to '%s' at %L",
3751 f->name, name, where);
3752 return false;
3753 }
3754
3755 f->actual = a;
3756 }
3757
3758 optional:
3759 /* At this point, all unmatched formal args must be optional. */
3760 for (f = formal; f; f = f->next)
3761 {
3762 if (f->actual == NULL && f->optional == 0)
3763 {
3764 gfc_error ("Missing actual argument '%s' in call to '%s' at %L",
3765 f->name, name, where);
3766 return false;
3767 }
3768 }
3769
3770 do_sort:
3771 /* Using the formal argument list, string the actual argument list
3772 together in a way that corresponds with the formal list. */
3773 actual = NULL;
3774
3775 for (f = formal; f; f = f->next)
3776 {
3777 if (f->actual && f->actual->label != NULL && f->ts.type)
3778 {
3779 gfc_error ("ALTERNATE RETURN not permitted at %L", where);
3780 return false;
3781 }
3782
3783 if (f->actual == NULL)
3784 {
3785 a = gfc_get_actual_arglist ();
3786 a->missing_arg_type = f->ts.type;
3787 }
3788 else
3789 a = f->actual;
3790
3791 if (actual == NULL)
3792 *ap = a;
3793 else
3794 actual->next = a;
3795
3796 actual = a;
3797 }
3798 actual->next = NULL; /* End the sorted argument list. */
3799
3800 return true;
3801 }
3802
3803
3804 /* Compare an actual argument list with an intrinsic's formal argument
3805 list. The lists are checked for agreement of type. We don't check
3806 for arrayness here. */
3807
3808 static bool
3809 check_arglist (gfc_actual_arglist **ap, gfc_intrinsic_sym *sym,
3810 int error_flag)
3811 {
3812 gfc_actual_arglist *actual;
3813 gfc_intrinsic_arg *formal;
3814 int i;
3815
3816 formal = sym->formal;
3817 actual = *ap;
3818
3819 i = 0;
3820 for (; formal; formal = formal->next, actual = actual->next, i++)
3821 {
3822 gfc_typespec ts;
3823
3824 if (actual->expr == NULL)
3825 continue;
3826
3827 ts = formal->ts;
3828
3829 /* A kind of 0 means we don't check for kind. */
3830 if (ts.kind == 0)
3831 ts.kind = actual->expr->ts.kind;
3832
3833 if (!gfc_compare_types (&ts, &actual->expr->ts))
3834 {
3835 if (error_flag)
3836 gfc_error ("Type of argument '%s' in call to '%s' at %L should "
3837 "be %s, not %s", gfc_current_intrinsic_arg[i]->name,
3838 gfc_current_intrinsic, &actual->expr->where,
3839 gfc_typename (&formal->ts),
3840 gfc_typename (&actual->expr->ts));
3841 return false;
3842 }
3843
3844 /* If the formal argument is INTENT([IN]OUT), check for definability. */
3845 if (formal->intent == INTENT_INOUT || formal->intent == INTENT_OUT)
3846 {
3847 const char* context = (error_flag
3848 ? _("actual argument to INTENT = OUT/INOUT")
3849 : NULL);
3850
3851 /* No pointer arguments for intrinsics. */
3852 if (!gfc_check_vardef_context (actual->expr, false, false, false, context))
3853 return false;
3854 }
3855 }
3856
3857 return true;
3858 }
3859
3860
3861 /* Given a pointer to an intrinsic symbol and an expression node that
3862 represent the function call to that subroutine, figure out the type
3863 of the result. This may involve calling a resolution subroutine. */
3864
3865 static void
3866 resolve_intrinsic (gfc_intrinsic_sym *specific, gfc_expr *e)
3867 {
3868 gfc_expr *a1, *a2, *a3, *a4, *a5;
3869 gfc_actual_arglist *arg;
3870
3871 if (specific->resolve.f1 == NULL)
3872 {
3873 if (e->value.function.name == NULL)
3874 e->value.function.name = specific->lib_name;
3875
3876 if (e->ts.type == BT_UNKNOWN)
3877 e->ts = specific->ts;
3878 return;
3879 }
3880
3881 arg = e->value.function.actual;
3882
3883 /* Special case hacks for MIN and MAX. */
3884 if (specific->resolve.f1m == gfc_resolve_max
3885 || specific->resolve.f1m == gfc_resolve_min)
3886 {
3887 (*specific->resolve.f1m) (e, arg);
3888 return;
3889 }
3890
3891 if (arg == NULL)
3892 {
3893 (*specific->resolve.f0) (e);
3894 return;
3895 }
3896
3897 a1 = arg->expr;
3898 arg = arg->next;
3899
3900 if (arg == NULL)
3901 {
3902 (*specific->resolve.f1) (e, a1);
3903 return;
3904 }
3905
3906 a2 = arg->expr;
3907 arg = arg->next;
3908
3909 if (arg == NULL)
3910 {
3911 (*specific->resolve.f2) (e, a1, a2);
3912 return;
3913 }
3914
3915 a3 = arg->expr;
3916 arg = arg->next;
3917
3918 if (arg == NULL)
3919 {
3920 (*specific->resolve.f3) (e, a1, a2, a3);
3921 return;
3922 }
3923
3924 a4 = arg->expr;
3925 arg = arg->next;
3926
3927 if (arg == NULL)
3928 {
3929 (*specific->resolve.f4) (e, a1, a2, a3, a4);
3930 return;
3931 }
3932
3933 a5 = arg->expr;
3934 arg = arg->next;
3935
3936 if (arg == NULL)
3937 {
3938 (*specific->resolve.f5) (e, a1, a2, a3, a4, a5);
3939 return;
3940 }
3941
3942 gfc_internal_error ("resolve_intrinsic(): Too many args for intrinsic");
3943 }
3944
3945
3946 /* Given an intrinsic symbol node and an expression node, call the
3947 simplification function (if there is one), perhaps replacing the
3948 expression with something simpler. We return false on an error
3949 of the simplification, true if the simplification worked, even
3950 if nothing has changed in the expression itself. */
3951
3952 static bool
3953 do_simplify (gfc_intrinsic_sym *specific, gfc_expr *e)
3954 {
3955 gfc_expr *result, *a1, *a2, *a3, *a4, *a5;
3956 gfc_actual_arglist *arg;
3957
3958 /* Max and min require special handling due to the variable number
3959 of args. */
3960 if (specific->simplify.f1 == gfc_simplify_min)
3961 {
3962 result = gfc_simplify_min (e);
3963 goto finish;
3964 }
3965
3966 if (specific->simplify.f1 == gfc_simplify_max)
3967 {
3968 result = gfc_simplify_max (e);
3969 goto finish;
3970 }
3971
3972 if (specific->simplify.f1 == NULL)
3973 {
3974 result = NULL;
3975 goto finish;
3976 }
3977
3978 arg = e->value.function.actual;
3979
3980 if (arg == NULL)
3981 {
3982 result = (*specific->simplify.f0) ();
3983 goto finish;
3984 }
3985
3986 a1 = arg->expr;
3987 arg = arg->next;
3988
3989 if (specific->simplify.cc == gfc_convert_constant
3990 || specific->simplify.cc == gfc_convert_char_constant)
3991 {
3992 result = specific->simplify.cc (a1, specific->ts.type, specific->ts.kind);
3993 goto finish;
3994 }
3995
3996 if (arg == NULL)
3997 result = (*specific->simplify.f1) (a1);
3998 else
3999 {
4000 a2 = arg->expr;
4001 arg = arg->next;
4002
4003 if (arg == NULL)
4004 result = (*specific->simplify.f2) (a1, a2);
4005 else
4006 {
4007 a3 = arg->expr;
4008 arg = arg->next;
4009
4010 if (arg == NULL)
4011 result = (*specific->simplify.f3) (a1, a2, a3);
4012 else
4013 {
4014 a4 = arg->expr;
4015 arg = arg->next;
4016
4017 if (arg == NULL)
4018 result = (*specific->simplify.f4) (a1, a2, a3, a4);
4019 else
4020 {
4021 a5 = arg->expr;
4022 arg = arg->next;
4023
4024 if (arg == NULL)
4025 result = (*specific->simplify.f5) (a1, a2, a3, a4, a5);
4026 else
4027 gfc_internal_error
4028 ("do_simplify(): Too many args for intrinsic");
4029 }
4030 }
4031 }
4032 }
4033
4034 finish:
4035 if (result == &gfc_bad_expr)
4036 return false;
4037
4038 if (result == NULL)
4039 resolve_intrinsic (specific, e); /* Must call at run-time */
4040 else
4041 {
4042 result->where = e->where;
4043 gfc_replace_expr (e, result);
4044 }
4045
4046 return true;
4047 }
4048
4049
4050 /* Initialize the gfc_current_intrinsic_arg[] array for the benefit of
4051 error messages. This subroutine returns false if a subroutine
4052 has more than MAX_INTRINSIC_ARGS, in which case the actual argument
4053 list cannot match any intrinsic. */
4054
4055 static void
4056 init_arglist (gfc_intrinsic_sym *isym)
4057 {
4058 gfc_intrinsic_arg *formal;
4059 int i;
4060
4061 gfc_current_intrinsic = isym->name;
4062
4063 i = 0;
4064 for (formal = isym->formal; formal; formal = formal->next)
4065 {
4066 if (i >= MAX_INTRINSIC_ARGS)
4067 gfc_internal_error ("init_arglist(): too many arguments");
4068 gfc_current_intrinsic_arg[i++] = formal;
4069 }
4070 }
4071
4072
4073 /* Given a pointer to an intrinsic symbol and an expression consisting
4074 of a function call, see if the function call is consistent with the
4075 intrinsic's formal argument list. Return true if the expression
4076 and intrinsic match, false otherwise. */
4077
4078 static bool
4079 check_specific (gfc_intrinsic_sym *specific, gfc_expr *expr, int error_flag)
4080 {
4081 gfc_actual_arglist *arg, **ap;
4082 bool t;
4083
4084 ap = &expr->value.function.actual;
4085
4086 init_arglist (specific);
4087
4088 /* Don't attempt to sort the argument list for min or max. */
4089 if (specific->check.f1m == gfc_check_min_max
4090 || specific->check.f1m == gfc_check_min_max_integer
4091 || specific->check.f1m == gfc_check_min_max_real
4092 || specific->check.f1m == gfc_check_min_max_double)
4093 {
4094 if (!do_ts29113_check (specific, *ap))
4095 return false;
4096 return (*specific->check.f1m) (*ap);
4097 }
4098
4099 if (!sort_actual (specific->name, ap, specific->formal, &expr->where))
4100 return false;
4101
4102 if (!do_ts29113_check (specific, *ap))
4103 return false;
4104
4105 if (specific->check.f3ml == gfc_check_minloc_maxloc)
4106 /* This is special because we might have to reorder the argument list. */
4107 t = gfc_check_minloc_maxloc (*ap);
4108 else if (specific->check.f3red == gfc_check_minval_maxval)
4109 /* This is also special because we also might have to reorder the
4110 argument list. */
4111 t = gfc_check_minval_maxval (*ap);
4112 else if (specific->check.f3red == gfc_check_product_sum)
4113 /* Same here. The difference to the previous case is that we allow a
4114 general numeric type. */
4115 t = gfc_check_product_sum (*ap);
4116 else if (specific->check.f3red == gfc_check_transf_bit_intrins)
4117 /* Same as for PRODUCT and SUM, but different checks. */
4118 t = gfc_check_transf_bit_intrins (*ap);
4119 else
4120 {
4121 if (specific->check.f1 == NULL)
4122 {
4123 t = check_arglist (ap, specific, error_flag);
4124 if (t)
4125 expr->ts = specific->ts;
4126 }
4127 else
4128 t = do_check (specific, *ap);
4129 }
4130
4131 /* Check conformance of elemental intrinsics. */
4132 if (t && specific->elemental)
4133 {
4134 int n = 0;
4135 gfc_expr *first_expr;
4136 arg = expr->value.function.actual;
4137
4138 /* There is no elemental intrinsic without arguments. */
4139 gcc_assert(arg != NULL);
4140 first_expr = arg->expr;
4141
4142 for ( ; arg && arg->expr; arg = arg->next, n++)
4143 if (!gfc_check_conformance (first_expr, arg->expr,
4144 "arguments '%s' and '%s' for "
4145 "intrinsic '%s'",
4146 gfc_current_intrinsic_arg[0]->name,
4147 gfc_current_intrinsic_arg[n]->name,
4148 gfc_current_intrinsic))
4149 return false;
4150 }
4151
4152 if (!t)
4153 remove_nullargs (ap);
4154
4155 return t;
4156 }
4157
4158
4159 /* Check whether an intrinsic belongs to whatever standard the user
4160 has chosen, taking also into account -fall-intrinsics. Here, no
4161 warning/error is emitted; but if symstd is not NULL, it is pointed to a
4162 textual representation of the symbols standard status (like
4163 "new in Fortran 2008", "a GNU extension" or "obsolescent in Fortran 95") that
4164 can be used to construct a detailed warning/error message in case of
4165 a false. */
4166
4167 bool
4168 gfc_check_intrinsic_standard (const gfc_intrinsic_sym* isym,
4169 const char** symstd, bool silent, locus where)
4170 {
4171 const char* symstd_msg;
4172
4173 /* For -fall-intrinsics, just succeed. */
4174 if (gfc_option.flag_all_intrinsics)
4175 return true;
4176
4177 /* Find the symbol's standard message for later usage. */
4178 switch (isym->standard)
4179 {
4180 case GFC_STD_F77:
4181 symstd_msg = "available since Fortran 77";
4182 break;
4183
4184 case GFC_STD_F95_OBS:
4185 symstd_msg = "obsolescent in Fortran 95";
4186 break;
4187
4188 case GFC_STD_F95_DEL:
4189 symstd_msg = "deleted in Fortran 95";
4190 break;
4191
4192 case GFC_STD_F95:
4193 symstd_msg = "new in Fortran 95";
4194 break;
4195
4196 case GFC_STD_F2003:
4197 symstd_msg = "new in Fortran 2003";
4198 break;
4199
4200 case GFC_STD_F2008:
4201 symstd_msg = "new in Fortran 2008";
4202 break;
4203
4204 case GFC_STD_F2008_TS:
4205 symstd_msg = "new in TS 29113/TS 18508";
4206 break;
4207
4208 case GFC_STD_GNU:
4209 symstd_msg = "a GNU Fortran extension";
4210 break;
4211
4212 case GFC_STD_LEGACY:
4213 symstd_msg = "for backward compatibility";
4214 break;
4215
4216 default:
4217 gfc_internal_error ("Invalid standard code on intrinsic '%s' (%d)",
4218 isym->name, isym->standard);
4219 }
4220
4221 /* If warning about the standard, warn and succeed. */
4222 if (gfc_option.warn_std & isym->standard)
4223 {
4224 /* Do only print a warning if not a GNU extension. */
4225 if (!silent && isym->standard != GFC_STD_GNU)
4226 gfc_warning ("Intrinsic '%s' (is %s) is used at %L",
4227 isym->name, _(symstd_msg), &where);
4228
4229 return true;
4230 }
4231
4232 /* If allowing the symbol's standard, succeed, too. */
4233 if (gfc_option.allow_std & isym->standard)
4234 return true;
4235
4236 /* Otherwise, fail. */
4237 if (symstd)
4238 *symstd = _(symstd_msg);
4239 return false;
4240 }
4241
4242
4243 /* See if a function call corresponds to an intrinsic function call.
4244 We return:
4245
4246 MATCH_YES if the call corresponds to an intrinsic, simplification
4247 is done if possible.
4248
4249 MATCH_NO if the call does not correspond to an intrinsic
4250
4251 MATCH_ERROR if the call corresponds to an intrinsic but there was an
4252 error during the simplification process.
4253
4254 The error_flag parameter enables an error reporting. */
4255
4256 match
4257 gfc_intrinsic_func_interface (gfc_expr *expr, int error_flag)
4258 {
4259 gfc_intrinsic_sym *isym, *specific;
4260 gfc_actual_arglist *actual;
4261 const char *name;
4262 int flag;
4263
4264 if (expr->value.function.isym != NULL)
4265 return (!do_simplify(expr->value.function.isym, expr))
4266 ? MATCH_ERROR : MATCH_YES;
4267
4268 if (!error_flag)
4269 gfc_push_suppress_errors ();
4270 flag = 0;
4271
4272 for (actual = expr->value.function.actual; actual; actual = actual->next)
4273 if (actual->expr != NULL)
4274 flag |= (actual->expr->ts.type != BT_INTEGER
4275 && actual->expr->ts.type != BT_CHARACTER);
4276
4277 name = expr->symtree->n.sym->name;
4278
4279 if (expr->symtree->n.sym->intmod_sym_id)
4280 {
4281 gfc_isym_id id = gfc_isym_id_by_intmod_sym (expr->symtree->n.sym);
4282 isym = specific = gfc_intrinsic_function_by_id (id);
4283 }
4284 else
4285 isym = specific = gfc_find_function (name);
4286
4287 if (isym == NULL)
4288 {
4289 if (!error_flag)
4290 gfc_pop_suppress_errors ();
4291 return MATCH_NO;
4292 }
4293
4294 if ((isym->id == GFC_ISYM_REAL || isym->id == GFC_ISYM_DBLE
4295 || isym->id == GFC_ISYM_CMPLX)
4296 && gfc_init_expr_flag
4297 && !gfc_notify_std (GFC_STD_F2003, "Function '%s' as initialization "
4298 "expression at %L", name, &expr->where))
4299 {
4300 if (!error_flag)
4301 gfc_pop_suppress_errors ();
4302 return MATCH_ERROR;
4303 }
4304
4305 gfc_current_intrinsic_where = &expr->where;
4306
4307 /* Bypass the generic list for min, max and ISO_C_Binding's c_loc. */
4308 if (isym->check.f1m == gfc_check_min_max)
4309 {
4310 init_arglist (isym);
4311
4312 if (isym->check.f1m(expr->value.function.actual))
4313 goto got_specific;
4314
4315 if (!error_flag)
4316 gfc_pop_suppress_errors ();
4317 return MATCH_NO;
4318 }
4319
4320 /* If the function is generic, check all of its specific
4321 incarnations. If the generic name is also a specific, we check
4322 that name last, so that any error message will correspond to the
4323 specific. */
4324 gfc_push_suppress_errors ();
4325
4326 if (isym->generic)
4327 {
4328 for (specific = isym->specific_head; specific;
4329 specific = specific->next)
4330 {
4331 if (specific == isym)
4332 continue;
4333 if (check_specific (specific, expr, 0))
4334 {
4335 gfc_pop_suppress_errors ();
4336 goto got_specific;
4337 }
4338 }
4339 }
4340
4341 gfc_pop_suppress_errors ();
4342
4343 if (!check_specific (isym, expr, error_flag))
4344 {
4345 if (!error_flag)
4346 gfc_pop_suppress_errors ();
4347 return MATCH_NO;
4348 }
4349
4350 specific = isym;
4351
4352 got_specific:
4353 expr->value.function.isym = specific;
4354 if (!expr->symtree->n.sym->module)
4355 gfc_intrinsic_symbol (expr->symtree->n.sym);
4356
4357 if (!error_flag)
4358 gfc_pop_suppress_errors ();
4359
4360 if (!do_simplify (specific, expr))
4361 return MATCH_ERROR;
4362
4363 /* F95, 7.1.6.1, Initialization expressions
4364 (4) An elemental intrinsic function reference of type integer or
4365 character where each argument is an initialization expression
4366 of type integer or character
4367
4368 F2003, 7.1.7 Initialization expression
4369 (4) A reference to an elemental standard intrinsic function,
4370 where each argument is an initialization expression */
4371
4372 if (gfc_init_expr_flag && isym->elemental && flag
4373 && !gfc_notify_std (GFC_STD_F2003, "Elemental function as "
4374 "initialization expression with non-integer/non-"
4375 "character arguments at %L", &expr->where))
4376 return MATCH_ERROR;
4377
4378 return MATCH_YES;
4379 }
4380
4381
4382 /* See if a CALL statement corresponds to an intrinsic subroutine.
4383 Returns MATCH_YES if the subroutine corresponds to an intrinsic,
4384 MATCH_NO if not, and MATCH_ERROR if there was an error (but did
4385 correspond). */
4386
4387 match
4388 gfc_intrinsic_sub_interface (gfc_code *c, int error_flag)
4389 {
4390 gfc_intrinsic_sym *isym;
4391 const char *name;
4392
4393 name = c->symtree->n.sym->name;
4394
4395 if (c->symtree->n.sym->intmod_sym_id)
4396 {
4397 gfc_isym_id id;
4398 id = gfc_isym_id_by_intmod_sym (c->symtree->n.sym);
4399 isym = gfc_intrinsic_subroutine_by_id (id);
4400 }
4401 else
4402 isym = gfc_find_subroutine (name);
4403 if (isym == NULL)
4404 return MATCH_NO;
4405
4406 if (!error_flag)
4407 gfc_push_suppress_errors ();
4408
4409 init_arglist (isym);
4410
4411 if (!sort_actual (name, &c->ext.actual, isym->formal, &c->loc))
4412 goto fail;
4413
4414 if (!do_ts29113_check (isym, c->ext.actual))
4415 goto fail;
4416
4417 if (isym->check.f1 != NULL)
4418 {
4419 if (!do_check (isym, c->ext.actual))
4420 goto fail;
4421 }
4422 else
4423 {
4424 if (!check_arglist (&c->ext.actual, isym, 1))
4425 goto fail;
4426 }
4427
4428 /* The subroutine corresponds to an intrinsic. Allow errors to be
4429 seen at this point. */
4430 if (!error_flag)
4431 gfc_pop_suppress_errors ();
4432
4433 c->resolved_isym = isym;
4434 if (isym->resolve.s1 != NULL)
4435 isym->resolve.s1 (c);
4436 else
4437 {
4438 c->resolved_sym = gfc_get_intrinsic_sub_symbol (isym->lib_name);
4439 c->resolved_sym->attr.elemental = isym->elemental;
4440 }
4441
4442 if (gfc_do_concurrent_flag && !isym->pure)
4443 {
4444 gfc_error ("Subroutine call to intrinsic '%s' in DO CONCURRENT "
4445 "block at %L is not PURE", name, &c->loc);
4446 return MATCH_ERROR;
4447 }
4448
4449 if (!isym->pure && gfc_pure (NULL))
4450 {
4451 gfc_error ("Subroutine call to intrinsic '%s' at %L is not PURE", name,
4452 &c->loc);
4453 return MATCH_ERROR;
4454 }
4455
4456 if (!isym->pure)
4457 gfc_unset_implicit_pure (NULL);
4458
4459 c->resolved_sym->attr.noreturn = isym->noreturn;
4460
4461 return MATCH_YES;
4462
4463 fail:
4464 if (!error_flag)
4465 gfc_pop_suppress_errors ();
4466 return MATCH_NO;
4467 }
4468
4469
4470 /* Call gfc_convert_type() with warning enabled. */
4471
4472 bool
4473 gfc_convert_type (gfc_expr *expr, gfc_typespec *ts, int eflag)
4474 {
4475 return gfc_convert_type_warn (expr, ts, eflag, 1);
4476 }
4477
4478
4479 /* Try to convert an expression (in place) from one type to another.
4480 'eflag' controls the behavior on error.
4481
4482 The possible values are:
4483
4484 1 Generate a gfc_error()
4485 2 Generate a gfc_internal_error().
4486
4487 'wflag' controls the warning related to conversion. */
4488
4489 bool
4490 gfc_convert_type_warn (gfc_expr *expr, gfc_typespec *ts, int eflag, int wflag)
4491 {
4492 gfc_intrinsic_sym *sym;
4493 gfc_typespec from_ts;
4494 locus old_where;
4495 gfc_expr *new_expr;
4496 int rank;
4497 mpz_t *shape;
4498
4499 from_ts = expr->ts; /* expr->ts gets clobbered */
4500
4501 if (ts->type == BT_UNKNOWN)
4502 goto bad;
4503
4504 /* NULL and zero size arrays get their type here. */
4505 if (expr->expr_type == EXPR_NULL
4506 || (expr->expr_type == EXPR_ARRAY && expr->value.constructor == NULL))
4507 {
4508 /* Sometimes the RHS acquire the type. */
4509 expr->ts = *ts;
4510 return true;
4511 }
4512
4513 if (expr->ts.type == BT_UNKNOWN)
4514 goto bad;
4515
4516 if (expr->ts.type == BT_DERIVED && ts->type == BT_DERIVED
4517 && gfc_compare_types (&expr->ts, ts))
4518 return true;
4519
4520 sym = find_conv (&expr->ts, ts);
4521 if (sym == NULL)
4522 goto bad;
4523
4524 /* At this point, a conversion is necessary. A warning may be needed. */
4525 if ((gfc_option.warn_std & sym->standard) != 0)
4526 {
4527 gfc_warning_now ("Extension: Conversion from %s to %s at %L",
4528 gfc_typename (&from_ts), gfc_typename (ts),
4529 &expr->where);
4530 }
4531 else if (wflag)
4532 {
4533 if (gfc_option.flag_range_check
4534 && expr->expr_type == EXPR_CONSTANT
4535 && from_ts.type == ts->type)
4536 {
4537 /* Do nothing. Constants of the same type are range-checked
4538 elsewhere. If a value too large for the target type is
4539 assigned, an error is generated. Not checking here avoids
4540 duplications of warnings/errors.
4541 If range checking was disabled, but -Wconversion enabled,
4542 a non range checked warning is generated below. */
4543 }
4544 else if (from_ts.type == BT_LOGICAL || ts->type == BT_LOGICAL)
4545 {
4546 /* Do nothing. This block exists only to simplify the other
4547 else-if expressions.
4548 LOGICAL <> LOGICAL no warning, independent of kind values
4549 LOGICAL <> INTEGER extension, warned elsewhere
4550 LOGICAL <> REAL invalid, error generated elsewhere
4551 LOGICAL <> COMPLEX invalid, error generated elsewhere */
4552 }
4553 else if (from_ts.type == ts->type
4554 || (from_ts.type == BT_INTEGER && ts->type == BT_REAL)
4555 || (from_ts.type == BT_INTEGER && ts->type == BT_COMPLEX)
4556 || (from_ts.type == BT_REAL && ts->type == BT_COMPLEX))
4557 {
4558 /* Larger kinds can hold values of smaller kinds without problems.
4559 Hence, only warn if target kind is smaller than the source
4560 kind - or if -Wconversion-extra is specified. */
4561 if (gfc_option.warn_conversion_extra)
4562 gfc_warning_now ("Conversion from %s to %s at %L",
4563 gfc_typename (&from_ts), gfc_typename (ts),
4564 &expr->where);
4565 else if (gfc_option.gfc_warn_conversion
4566 && from_ts.kind > ts->kind)
4567 gfc_warning_now ("Possible change of value in conversion "
4568 "from %s to %s at %L", gfc_typename (&from_ts),
4569 gfc_typename (ts), &expr->where);
4570 }
4571 else if ((from_ts.type == BT_REAL && ts->type == BT_INTEGER)
4572 || (from_ts.type == BT_COMPLEX && ts->type == BT_INTEGER)
4573 || (from_ts.type == BT_COMPLEX && ts->type == BT_REAL))
4574 {
4575 /* Conversion from REAL/COMPLEX to INTEGER or COMPLEX to REAL
4576 usually comes with a loss of information, regardless of kinds. */
4577 if (gfc_option.warn_conversion_extra
4578 || gfc_option.gfc_warn_conversion)
4579 gfc_warning_now ("Possible change of value in conversion "
4580 "from %s to %s at %L", gfc_typename (&from_ts),
4581 gfc_typename (ts), &expr->where);
4582 }
4583 else if (from_ts.type == BT_HOLLERITH || ts->type == BT_HOLLERITH)
4584 {
4585 /* If HOLLERITH is involved, all bets are off. */
4586 if (gfc_option.warn_conversion_extra
4587 || gfc_option.gfc_warn_conversion)
4588 gfc_warning_now ("Conversion from %s to %s at %L",
4589 gfc_typename (&from_ts), gfc_typename (ts),
4590 &expr->where);
4591 }
4592 else
4593 gcc_unreachable ();
4594 }
4595
4596 /* Insert a pre-resolved function call to the right function. */
4597 old_where = expr->where;
4598 rank = expr->rank;
4599 shape = expr->shape;
4600
4601 new_expr = gfc_get_expr ();
4602 *new_expr = *expr;
4603
4604 new_expr = gfc_build_conversion (new_expr);
4605 new_expr->value.function.name = sym->lib_name;
4606 new_expr->value.function.isym = sym;
4607 new_expr->where = old_where;
4608 new_expr->rank = rank;
4609 new_expr->shape = gfc_copy_shape (shape, rank);
4610
4611 gfc_get_ha_sym_tree (sym->name, &new_expr->symtree);
4612 new_expr->symtree->n.sym->result = new_expr->symtree->n.sym;
4613 new_expr->symtree->n.sym->ts = *ts;
4614 new_expr->symtree->n.sym->attr.flavor = FL_PROCEDURE;
4615 new_expr->symtree->n.sym->attr.function = 1;
4616 new_expr->symtree->n.sym->attr.elemental = 1;
4617 new_expr->symtree->n.sym->attr.pure = 1;
4618 new_expr->symtree->n.sym->attr.referenced = 1;
4619 gfc_intrinsic_symbol(new_expr->symtree->n.sym);
4620 gfc_commit_symbol (new_expr->symtree->n.sym);
4621
4622 *expr = *new_expr;
4623
4624 free (new_expr);
4625 expr->ts = *ts;
4626
4627 if (gfc_is_constant_expr (expr->value.function.actual->expr)
4628 && !do_simplify (sym, expr))
4629 {
4630
4631 if (eflag == 2)
4632 goto bad;
4633 return false; /* Error already generated in do_simplify() */
4634 }
4635
4636 return true;
4637
4638 bad:
4639 if (eflag == 1)
4640 {
4641 gfc_error ("Can't convert %s to %s at %L",
4642 gfc_typename (&from_ts), gfc_typename (ts), &expr->where);
4643 return false;
4644 }
4645
4646 gfc_internal_error ("Can't convert %s to %s at %L",
4647 gfc_typename (&from_ts), gfc_typename (ts),
4648 &expr->where);
4649 /* Not reached */
4650 }
4651
4652
4653 bool
4654 gfc_convert_chartype (gfc_expr *expr, gfc_typespec *ts)
4655 {
4656 gfc_intrinsic_sym *sym;
4657 locus old_where;
4658 gfc_expr *new_expr;
4659 int rank;
4660 mpz_t *shape;
4661
4662 gcc_assert (expr->ts.type == BT_CHARACTER && ts->type == BT_CHARACTER);
4663
4664 sym = find_char_conv (&expr->ts, ts);
4665 gcc_assert (sym);
4666
4667 /* Insert a pre-resolved function call to the right function. */
4668 old_where = expr->where;
4669 rank = expr->rank;
4670 shape = expr->shape;
4671
4672 new_expr = gfc_get_expr ();
4673 *new_expr = *expr;
4674
4675 new_expr = gfc_build_conversion (new_expr);
4676 new_expr->value.function.name = sym->lib_name;
4677 new_expr->value.function.isym = sym;
4678 new_expr->where = old_where;
4679 new_expr->rank = rank;
4680 new_expr->shape = gfc_copy_shape (shape, rank);
4681
4682 gfc_get_ha_sym_tree (sym->name, &new_expr->symtree);
4683 new_expr->symtree->n.sym->ts = *ts;
4684 new_expr->symtree->n.sym->attr.flavor = FL_PROCEDURE;
4685 new_expr->symtree->n.sym->attr.function = 1;
4686 new_expr->symtree->n.sym->attr.elemental = 1;
4687 new_expr->symtree->n.sym->attr.referenced = 1;
4688 gfc_intrinsic_symbol(new_expr->symtree->n.sym);
4689 gfc_commit_symbol (new_expr->symtree->n.sym);
4690
4691 *expr = *new_expr;
4692
4693 free (new_expr);
4694 expr->ts = *ts;
4695
4696 if (gfc_is_constant_expr (expr->value.function.actual->expr)
4697 && !do_simplify (sym, expr))
4698 {
4699 /* Error already generated in do_simplify() */
4700 return false;
4701 }
4702
4703 return true;
4704 }
4705
4706
4707 /* Check if the passed name is name of an intrinsic (taking into account the
4708 current -std=* and -fall-intrinsic settings). If it is, see if we should
4709 warn about this as a user-procedure having the same name as an intrinsic
4710 (-Wintrinsic-shadow enabled) and do so if we should. */
4711
4712 void
4713 gfc_warn_intrinsic_shadow (const gfc_symbol* sym, bool in_module, bool func)
4714 {
4715 gfc_intrinsic_sym* isym;
4716
4717 /* If the warning is disabled, do nothing at all. */
4718 if (!gfc_option.warn_intrinsic_shadow)
4719 return;
4720
4721 /* Try to find an intrinsic of the same name. */
4722 if (func)
4723 isym = gfc_find_function (sym->name);
4724 else
4725 isym = gfc_find_subroutine (sym->name);
4726
4727 /* If no intrinsic was found with this name or it's not included in the
4728 selected standard, everything's fine. */
4729 if (!isym || !gfc_check_intrinsic_standard (isym, NULL, true,
4730 sym->declared_at))
4731 return;
4732
4733 /* Emit the warning. */
4734 if (in_module || sym->ns->proc_name)
4735 gfc_warning ("'%s' declared at %L may shadow the intrinsic of the same"
4736 " name. In order to call the intrinsic, explicit INTRINSIC"
4737 " declarations may be required.",
4738 sym->name, &sym->declared_at);
4739 else
4740 gfc_warning ("'%s' declared at %L is also the name of an intrinsic. It can"
4741 " only be called via an explicit interface or if declared"
4742 " EXTERNAL.", sym->name, &sym->declared_at);
4743 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org