2 Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
3 Contributed by Andy Vaught & Katherine Holcomb
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 /* These functions check to see if an argument list is compatible with
24 a particular intrinsic function or subroutine. Presence of
25 required arguments has already been established, the argument list
26 has been sorted into the right order and has NULL arguments in the
27 correct places for missing optional arguments. */
37 #include "intrinsic.h"
40 /* The fundamental complaint function of this source file. This
41 function can be called in all kinds of ways. */
44 must_be (gfc_expr * e, int n, const char *thing)
47 gfc_error ("'%s' argument of '%s' intrinsic at %L must be %s",
48 gfc_current_intrinsic_arg[n], gfc_current_intrinsic, &e->where,
53 /* Check the type of an expression. */
56 type_check (gfc_expr * e, int n, bt type)
59 if (e->ts.type == type)
62 must_be (e, n, gfc_basic_typename (type));
68 /* Check that the expression is a numeric type. */
71 numeric_check (gfc_expr * e, int n)
74 if (gfc_numeric_ts (&e->ts))
77 must_be (e, n, "a numeric type");
83 /* Check that an expression is integer or real. */
86 int_or_real_check (gfc_expr * e, int n)
89 if (e->ts.type != BT_INTEGER && e->ts.type != BT_REAL)
91 must_be (e, n, "INTEGER or REAL");
99 /* Check that the expression is an optional constant integer
100 and that it specifies a valid kind for that type. */
103 kind_check (gfc_expr * k, int n, bt type)
110 if (type_check (k, n, BT_INTEGER) == FAILURE)
113 if (k->expr_type != EXPR_CONSTANT)
115 must_be (k, n, "a constant");
119 if (gfc_extract_int (k, &kind) != NULL
120 || gfc_validate_kind (type, kind, true) < 0)
122 gfc_error ("Invalid kind for %s at %L", gfc_basic_typename (type),
131 /* Make sure the expression is a double precision real. */
134 double_check (gfc_expr * d, int n)
136 if (type_check (d, n, BT_REAL) == FAILURE)
139 if (d->ts.kind != gfc_default_double_kind)
141 must_be (d, n, "double precision");
149 /* Make sure the expression is a logical array. */
152 logical_array_check (gfc_expr * array, int n)
155 if (array->ts.type != BT_LOGICAL || array->rank == 0)
157 must_be (array, n, "a logical array");
165 /* Make sure an expression is an array. */
168 array_check (gfc_expr * e, int n)
174 must_be (e, n, "an array");
180 /* Make sure an expression is a scalar. */
183 scalar_check (gfc_expr * e, int n)
189 must_be (e, n, "a scalar");
195 /* Make sure two expression have the same type. */
198 same_type_check (gfc_expr * e, int n, gfc_expr * f, int m)
202 if (gfc_compare_types (&e->ts, &f->ts))
205 sprintf (message, "the same type and kind as '%s'",
206 gfc_current_intrinsic_arg[n]);
208 must_be (f, m, message);
214 /* Make sure that an expression has a certain (nonzero) rank. */
217 rank_check (gfc_expr * e, int n, int rank)
224 sprintf (message, "of rank %d", rank);
226 must_be (e, n, message);
232 /* Make sure a variable expression is not an optional dummy argument. */
235 nonoptional_check (gfc_expr * e, int n)
238 if (e->expr_type == EXPR_VARIABLE && e->symtree->n.sym->attr.optional)
240 gfc_error ("'%s' argument of '%s' intrinsic at %L must not be OPTIONAL",
241 gfc_current_intrinsic_arg[n], gfc_current_intrinsic,
246 /* TODO: Recursive check on nonoptional variables? */
252 /* Check that an expression has a particular kind. */
255 kind_value_check (gfc_expr * e, int n, int k)
262 sprintf (message, "of kind %d", k);
264 must_be (e, n, message);
269 /* Make sure an expression is a variable. */
272 variable_check (gfc_expr * e, int n)
275 if ((e->expr_type == EXPR_VARIABLE
276 && e->symtree->n.sym->attr.flavor != FL_PARAMETER)
277 || (e->expr_type == EXPR_FUNCTION
278 && e->symtree->n.sym->result == e->symtree->n.sym))
281 if (e->expr_type == EXPR_VARIABLE
282 && e->symtree->n.sym->attr.intent == INTENT_IN)
284 gfc_error ("'%s' argument of '%s' intrinsic at %L cannot be INTENT(IN)",
285 gfc_current_intrinsic_arg[n], gfc_current_intrinsic,
290 must_be (e, n, "a variable");
296 /* Check the common DIM parameter for correctness. */
299 dim_check (gfc_expr * dim, int n, int optional)
307 if (nonoptional_check (dim, n) == FAILURE)
315 gfc_error ("Missing DIM parameter in intrinsic '%s' at %L",
316 gfc_current_intrinsic, gfc_current_intrinsic_where);
320 if (type_check (dim, n, BT_INTEGER) == FAILURE)
323 if (scalar_check (dim, n) == FAILURE)
330 /* If a DIM parameter is a constant, make sure that it is greater than
331 zero and less than or equal to the rank of the given array. If
332 allow_assumed is zero then dim must be less than the rank of the array
333 for assumed size arrays. */
336 dim_rank_check (gfc_expr * dim, gfc_expr * array, int allow_assumed)
341 if (dim->expr_type != EXPR_CONSTANT || array->expr_type != EXPR_VARIABLE)
344 ar = gfc_find_array_ref (array);
346 if (ar->as->type == AS_ASSUMED_SIZE && !allow_assumed)
349 if (mpz_cmp_ui (dim->value.integer, 1) < 0
350 || mpz_cmp_ui (dim->value.integer, rank) > 0)
352 gfc_error ("'dim' argument of '%s' intrinsic at %L is not a valid "
353 "dimension index", gfc_current_intrinsic, &dim->where);
362 /***** Check functions *****/
364 /* Check subroutine suitable for intrinsics taking a real argument and
365 a kind argument for the result. */
368 check_a_kind (gfc_expr * a, gfc_expr * kind, bt type)
371 if (type_check (a, 0, BT_REAL) == FAILURE)
373 if (kind_check (kind, 1, type) == FAILURE)
379 /* Check subroutine suitable for ceiling, floor and nint. */
382 gfc_check_a_ikind (gfc_expr * a, gfc_expr * kind)
385 return check_a_kind (a, kind, BT_INTEGER);
388 /* Check subroutine suitable for aint, anint. */
391 gfc_check_a_xkind (gfc_expr * a, gfc_expr * kind)
394 return check_a_kind (a, kind, BT_REAL);
398 gfc_check_abs (gfc_expr * a)
401 if (numeric_check (a, 0) == FAILURE)
409 gfc_check_all_any (gfc_expr * mask, gfc_expr * dim)
412 if (logical_array_check (mask, 0) == FAILURE)
415 if (dim_check (dim, 1, 1) == FAILURE)
423 gfc_check_allocated (gfc_expr * array)
426 if (variable_check (array, 0) == FAILURE)
429 if (array_check (array, 0) == FAILURE)
432 if (!array->symtree->n.sym->attr.allocatable)
434 must_be (array, 0, "ALLOCATABLE");
442 /* Common check function where the first argument must be real or
443 integer and the second argument must be the same as the first. */
446 gfc_check_a_p (gfc_expr * a, gfc_expr * p)
449 if (int_or_real_check (a, 0) == FAILURE)
452 if (same_type_check (a, 0, p, 1) == FAILURE)
460 gfc_check_associated (gfc_expr * pointer, gfc_expr * target)
462 symbol_attribute attr;
466 if (variable_check (pointer, 0) == FAILURE)
469 attr = gfc_variable_attr (pointer, NULL);
472 must_be (pointer, 0, "a POINTER");
479 /* Target argument is optional. */
480 if (target->expr_type == EXPR_NULL)
482 gfc_error ("NULL pointer at %L is not permitted as actual argument "
483 "of '%s' intrinsic function",
484 &target->where, gfc_current_intrinsic);
488 attr = gfc_variable_attr (target, NULL);
489 if (!attr.pointer && !attr.target)
491 must_be (target, 1, "a POINTER or a TARGET");
496 if (same_type_check (pointer, 0, target, 1) == FAILURE)
498 if (rank_check (target, 0, pointer->rank) == FAILURE)
500 if (target->rank > 0)
502 for (i = 0; i < target->rank; i++)
503 if (target->ref->u.ar.dimen_type[i] == DIMEN_VECTOR)
505 gfc_error ("Array section with a vector subscript at %L shall not "
506 "be the target of an pointer",
517 gfc_check_atan2 (gfc_expr * y, gfc_expr * x)
519 if (type_check (y, 0, BT_REAL) == FAILURE)
521 if (same_type_check (y, 0, x, 1) == FAILURE)
529 gfc_check_btest (gfc_expr * i, gfc_expr * pos)
532 if (type_check (i, 0, BT_INTEGER) == FAILURE)
534 if (type_check (pos, 1, BT_INTEGER) == FAILURE)
542 gfc_check_char (gfc_expr * i, gfc_expr * kind)
545 if (type_check (i, 0, BT_INTEGER) == FAILURE)
547 if (kind_check (kind, 1, BT_CHARACTER) == FAILURE)
555 gfc_check_cmplx (gfc_expr * x, gfc_expr * y, gfc_expr * kind)
558 if (numeric_check (x, 0) == FAILURE)
563 if (numeric_check (y, 1) == FAILURE)
566 if (x->ts.type == BT_COMPLEX)
568 must_be (y, 1, "not be present if 'x' is COMPLEX");
573 if (kind_check (kind, 2, BT_COMPLEX) == FAILURE)
581 gfc_check_count (gfc_expr * mask, gfc_expr * dim)
584 if (logical_array_check (mask, 0) == FAILURE)
586 if (dim_check (dim, 1, 1) == FAILURE)
594 gfc_check_cshift (gfc_expr * array, gfc_expr * shift, gfc_expr * dim)
597 if (array_check (array, 0) == FAILURE)
600 if (array->rank == 1)
602 if (scalar_check (shift, 1) == FAILURE)
607 /* TODO: more requirements on shift parameter. */
610 if (dim_check (dim, 2, 1) == FAILURE)
618 gfc_check_dcmplx (gfc_expr * x, gfc_expr * y)
621 if (numeric_check (x, 0) == FAILURE)
626 if (numeric_check (y, 1) == FAILURE)
629 if (x->ts.type == BT_COMPLEX)
631 must_be (y, 1, "not be present if 'x' is COMPLEX");
641 gfc_check_dble (gfc_expr * x)
644 if (numeric_check (x, 0) == FAILURE)
652 gfc_check_digits (gfc_expr * x)
655 if (int_or_real_check (x, 0) == FAILURE)
663 gfc_check_dot_product (gfc_expr * vector_a, gfc_expr * vector_b)
666 switch (vector_a->ts.type)
669 if (type_check (vector_b, 1, BT_LOGICAL) == FAILURE)
676 if (numeric_check (vector_b, 1) == FAILURE)
681 must_be (vector_a, 0, "numeric or LOGICAL");
685 if (rank_check (vector_a, 0, 1) == FAILURE)
688 if (rank_check (vector_b, 1, 1) == FAILURE)
696 gfc_check_eoshift (gfc_expr * array, gfc_expr * shift, gfc_expr * boundary,
700 if (array_check (array, 0) == FAILURE)
703 if (type_check (shift, 1, BT_INTEGER) == FAILURE)
706 if (array->rank == 1)
708 if (scalar_check (shift, 2) == FAILURE)
713 /* TODO: more weird restrictions on shift. */
716 if (boundary != NULL)
718 if (same_type_check (array, 0, boundary, 2) == FAILURE)
721 /* TODO: more restrictions on boundary. */
724 if (dim_check (dim, 1, 1) == FAILURE)
733 gfc_check_huge (gfc_expr * x)
736 if (int_or_real_check (x, 0) == FAILURE)
743 /* Check that the single argument is an integer. */
746 gfc_check_i (gfc_expr * i)
749 if (type_check (i, 0, BT_INTEGER) == FAILURE)
757 gfc_check_iand (gfc_expr * i, gfc_expr * j)
760 if (type_check (i, 0, BT_INTEGER) == FAILURE
761 || type_check (j, 1, BT_INTEGER) == FAILURE)
764 if (same_type_check (i, 0, j, 1) == FAILURE)
772 gfc_check_ibclr (gfc_expr * i, gfc_expr * pos)
775 if (type_check (i, 0, BT_INTEGER) == FAILURE
776 || type_check (pos, 1, BT_INTEGER) == FAILURE
777 || kind_value_check (pos, 1, gfc_default_integer_kind) == FAILURE)
785 gfc_check_ibits (gfc_expr * i, gfc_expr * pos, gfc_expr * len)
788 if (type_check (i, 0, BT_INTEGER) == FAILURE
789 || type_check (pos, 1, BT_INTEGER) == FAILURE
790 || kind_value_check (pos, 1, gfc_default_integer_kind) == FAILURE
791 || type_check (len, 2, BT_INTEGER) == FAILURE)
799 gfc_check_ibset (gfc_expr * i, gfc_expr * pos)
802 if (type_check (i, 0, BT_INTEGER) == FAILURE
803 || type_check (pos, 1, BT_INTEGER) == FAILURE
804 || kind_value_check (pos, 1, gfc_default_integer_kind) == FAILURE)
812 gfc_check_idnint (gfc_expr * a)
815 if (double_check (a, 0) == FAILURE)
823 gfc_check_ieor (gfc_expr * i, gfc_expr * j)
826 if (type_check (i, 0, BT_INTEGER) == FAILURE
827 || type_check (j, 1, BT_INTEGER) == FAILURE)
830 if (same_type_check (i, 0, j, 1) == FAILURE)
838 gfc_check_index (gfc_expr * string, gfc_expr * substring, gfc_expr * back)
841 if (type_check (string, 0, BT_CHARACTER) == FAILURE
842 || type_check (substring, 1, BT_CHARACTER) == FAILURE)
846 if (back != NULL && type_check (back, 2, BT_LOGICAL) == FAILURE)
849 if (string->ts.kind != substring->ts.kind)
851 must_be (substring, 1, "the same kind as 'string'");
860 gfc_check_int (gfc_expr * x, gfc_expr * kind)
863 if (numeric_check (x, 0) == FAILURE
864 || kind_check (kind, 1, BT_INTEGER) == FAILURE)
872 gfc_check_ior (gfc_expr * i, gfc_expr * j)
875 if (type_check (i, 0, BT_INTEGER) == FAILURE
876 || type_check (j, 1, BT_INTEGER) == FAILURE)
879 if (same_type_check (i, 0, j, 1) == FAILURE)
887 gfc_check_ishft (gfc_expr * i, gfc_expr * shift)
890 if (type_check (i, 0, BT_INTEGER) == FAILURE
891 || type_check (shift, 1, BT_INTEGER) == FAILURE)
899 gfc_check_ishftc (gfc_expr * i, gfc_expr * shift, gfc_expr * size)
902 if (type_check (i, 0, BT_INTEGER) == FAILURE
903 || type_check (shift, 1, BT_INTEGER) == FAILURE)
906 if (size != NULL && type_check (size, 2, BT_INTEGER) == FAILURE)
914 gfc_check_kind (gfc_expr * x)
917 if (x->ts.type == BT_DERIVED)
919 must_be (x, 0, "a non-derived type");
928 gfc_check_lbound (gfc_expr * array, gfc_expr * dim)
931 if (array_check (array, 0) == FAILURE)
936 if (dim_check (dim, 1, 1) == FAILURE)
939 if (dim_rank_check (dim, array, 1) == FAILURE)
947 gfc_check_logical (gfc_expr * a, gfc_expr * kind)
950 if (type_check (a, 0, BT_LOGICAL) == FAILURE)
952 if (kind_check (kind, 1, BT_LOGICAL) == FAILURE)
959 /* Min/max family. */
962 min_max_args (gfc_actual_arglist * arg)
965 if (arg == NULL || arg->next == NULL)
967 gfc_error ("Intrinsic '%s' at %L must have at least two arguments",
968 gfc_current_intrinsic, gfc_current_intrinsic_where);
977 check_rest (bt type, int kind, gfc_actual_arglist * arg)
982 if (min_max_args (arg) == FAILURE)
987 for (; arg; arg = arg->next, n++)
990 if (x->ts.type != type || x->ts.kind != kind)
992 if (x->ts.type == type)
994 if (gfc_notify_std (GFC_STD_GNU,
995 "Extension: Different type kinds at %L", &x->where)
1001 gfc_error ("'a%d' argument of '%s' intrinsic at %L must be %s(%d)",
1002 n, gfc_current_intrinsic, &x->where,
1003 gfc_basic_typename (type), kind);
1014 gfc_check_min_max (gfc_actual_arglist * arg)
1018 if (min_max_args (arg) == FAILURE)
1023 if (x->ts.type != BT_INTEGER && x->ts.type != BT_REAL)
1026 ("'a1' argument of '%s' intrinsic at %L must be INTEGER or REAL",
1027 gfc_current_intrinsic, &x->where);
1031 return check_rest (x->ts.type, x->ts.kind, arg);
1036 gfc_check_min_max_integer (gfc_actual_arglist * arg)
1039 return check_rest (BT_INTEGER, gfc_default_integer_kind, arg);
1044 gfc_check_min_max_real (gfc_actual_arglist * arg)
1047 return check_rest (BT_REAL, gfc_default_real_kind, arg);
1052 gfc_check_min_max_double (gfc_actual_arglist * arg)
1055 return check_rest (BT_REAL, gfc_default_double_kind, arg);
1058 /* End of min/max family. */
1062 gfc_check_matmul (gfc_expr * matrix_a, gfc_expr * matrix_b)
1065 if ((matrix_a->ts.type != BT_LOGICAL) && !gfc_numeric_ts (&matrix_b->ts))
1067 must_be (matrix_a, 0, "numeric or LOGICAL");
1071 if ((matrix_b->ts.type != BT_LOGICAL) && !gfc_numeric_ts (&matrix_a->ts))
1073 must_be (matrix_b, 0, "numeric or LOGICAL");
1077 switch (matrix_a->rank)
1080 if (rank_check (matrix_b, 1, 2) == FAILURE)
1085 if (matrix_b->rank == 2)
1087 if (rank_check (matrix_b, 1, 1) == FAILURE)
1092 must_be (matrix_a, 0, "of rank 1 or 2");
1100 /* Whoever came up with this interface was probably on something.
1101 The possibilities for the occupation of the second and third
1108 NULL MASK minloc(array, mask=m)
1111 I.e. in the case of minloc(array,mask), mask will be in the second
1112 position of the argument list and we'll have to fix that up. */
1115 gfc_check_minloc_maxloc (gfc_actual_arglist * ap)
1117 gfc_expr *a, *m, *d;
1120 if (int_or_real_check (a, 0) == FAILURE
1121 || array_check (a, 0) == FAILURE)
1125 m = ap->next->next->expr;
1127 if (m == NULL && d != NULL && d->ts.type == BT_LOGICAL
1128 && ap->next->name[0] == '\0')
1133 ap->next->expr = NULL;
1134 ap->next->next->expr = m;
1138 && (scalar_check (d, 1) == FAILURE
1139 || type_check (d, 1, BT_INTEGER) == FAILURE))
1142 if (m != NULL && type_check (m, 2, BT_LOGICAL) == FAILURE)
1149 /* Similar to minloc/maxloc, the argument list might need to be
1150 reordered for the MINVAL, MAXVAL, PRODUCT, and SUM intrinsics. The
1151 difference is that MINLOC/MAXLOC take an additional KIND argument.
1152 The possibilities are:
1158 NULL MASK minval(array, mask=m)
1161 I.e. in the case of minval(array,mask), mask will be in the second
1162 position of the argument list and we'll have to fix that up. */
1165 check_reduction (gfc_actual_arglist * ap)
1170 m = ap->next->next->expr;
1172 if (m == NULL && d != NULL && d->ts.type == BT_LOGICAL
1173 && ap->next->name[0] == '\0')
1178 ap->next->expr = NULL;
1179 ap->next->next->expr = m;
1183 && (scalar_check (d, 1) == FAILURE
1184 || type_check (d, 1, BT_INTEGER) == FAILURE))
1187 if (m != NULL && type_check (m, 2, BT_LOGICAL) == FAILURE)
1195 gfc_check_minval_maxval (gfc_actual_arglist * ap)
1198 if (int_or_real_check (ap->expr, 0) == FAILURE
1199 || array_check (ap->expr, 0) == FAILURE)
1202 return check_reduction (ap);
1207 gfc_check_product_sum (gfc_actual_arglist * ap)
1210 if (numeric_check (ap->expr, 0) == FAILURE
1211 || array_check (ap->expr, 0) == FAILURE)
1214 return check_reduction (ap);
1219 gfc_check_merge (gfc_expr * tsource, gfc_expr * fsource, gfc_expr * mask)
1222 if (same_type_check (tsource, 0, fsource, 1) == FAILURE)
1225 if (type_check (mask, 2, BT_LOGICAL) == FAILURE)
1233 gfc_check_nearest (gfc_expr * x, gfc_expr * s)
1236 if (type_check (x, 0, BT_REAL) == FAILURE)
1239 if (type_check (s, 1, BT_REAL) == FAILURE)
1247 gfc_check_null (gfc_expr * mold)
1249 symbol_attribute attr;
1254 if (variable_check (mold, 0) == FAILURE)
1257 attr = gfc_variable_attr (mold, NULL);
1261 must_be (mold, 0, "a POINTER");
1270 gfc_check_pack (gfc_expr * array, gfc_expr * mask, gfc_expr * vector)
1273 if (array_check (array, 0) == FAILURE)
1276 if (type_check (mask, 1, BT_LOGICAL) == FAILURE)
1279 if (mask->rank != 0 && mask->rank != array->rank)
1281 must_be (array, 0, "conformable with 'mask' argument");
1287 if (same_type_check (array, 0, vector, 2) == FAILURE)
1290 if (rank_check (vector, 2, 1) == FAILURE)
1293 /* TODO: More constraints here. */
1301 gfc_check_precision (gfc_expr * x)
1304 if (x->ts.type != BT_REAL && x->ts.type != BT_COMPLEX)
1306 must_be (x, 0, "of type REAL or COMPLEX");
1315 gfc_check_present (gfc_expr * a)
1319 if (variable_check (a, 0) == FAILURE)
1322 sym = a->symtree->n.sym;
1323 if (!sym->attr.dummy)
1325 must_be (a, 0, "a dummy variable");
1329 if (!sym->attr.optional)
1331 must_be (a, 0, "an OPTIONAL dummy variable");
1340 gfc_check_radix (gfc_expr * x)
1343 if (int_or_real_check (x, 0) == FAILURE)
1351 gfc_check_range (gfc_expr * x)
1354 if (numeric_check (x, 0) == FAILURE)
1361 /* real, float, sngl. */
1363 gfc_check_real (gfc_expr * a, gfc_expr * kind)
1366 if (numeric_check (a, 0) == FAILURE)
1369 if (kind_check (kind, 1, BT_REAL) == FAILURE)
1377 gfc_check_repeat (gfc_expr * x, gfc_expr * y)
1380 if (type_check (x, 0, BT_CHARACTER) == FAILURE)
1383 if (scalar_check (x, 0) == FAILURE)
1386 if (type_check (y, 0, BT_INTEGER) == FAILURE)
1389 if (scalar_check (y, 1) == FAILURE)
1397 gfc_check_reshape (gfc_expr * source, gfc_expr * shape,
1398 gfc_expr * pad, gfc_expr * order)
1403 if (array_check (source, 0) == FAILURE)
1406 if (rank_check (shape, 1, 1) == FAILURE)
1409 if (type_check (shape, 1, BT_INTEGER) == FAILURE)
1412 if (gfc_array_size (shape, &size) != SUCCESS)
1414 gfc_error ("'shape' argument of 'reshape' intrinsic at %L must be an "
1415 "array of constant size", &shape->where);
1419 m = mpz_cmp_ui (size, GFC_MAX_DIMENSIONS);
1425 ("'shape' argument of 'reshape' intrinsic at %L has more than "
1426 stringize (GFC_MAX_DIMENSIONS) " elements", &shape->where);
1432 if (same_type_check (source, 0, pad, 2) == FAILURE)
1434 if (array_check (pad, 2) == FAILURE)
1438 if (order != NULL && array_check (order, 3) == FAILURE)
1446 gfc_check_scale (gfc_expr * x, gfc_expr * i)
1449 if (type_check (x, 0, BT_REAL) == FAILURE)
1452 if (type_check (i, 1, BT_INTEGER) == FAILURE)
1460 gfc_check_scan (gfc_expr * x, gfc_expr * y, gfc_expr * z)
1463 if (type_check (x, 0, BT_CHARACTER) == FAILURE)
1466 if (type_check (y, 1, BT_CHARACTER) == FAILURE)
1469 if (z != NULL && type_check (z, 2, BT_LOGICAL) == FAILURE)
1472 if (same_type_check (x, 0, y, 1) == FAILURE)
1480 gfc_check_selected_real_kind (gfc_expr * p, gfc_expr * r)
1483 if (p == NULL && r == NULL)
1485 gfc_error ("Missing arguments to %s intrinsic at %L",
1486 gfc_current_intrinsic, gfc_current_intrinsic_where);
1491 if (p != NULL && type_check (p, 0, BT_INTEGER) == FAILURE)
1494 if (r != NULL && type_check (r, 1, BT_INTEGER) == FAILURE)
1502 gfc_check_set_exponent (gfc_expr * x, gfc_expr * i)
1505 if (type_check (x, 0, BT_REAL) == FAILURE)
1508 if (type_check (i, 1, BT_INTEGER) == FAILURE)
1516 gfc_check_shape (gfc_expr * source)
1520 if (source->rank == 0 || source->expr_type != EXPR_VARIABLE)
1523 ar = gfc_find_array_ref (source);
1525 if (ar->as && ar->as->type == AS_ASSUMED_SIZE)
1527 gfc_error ("'source' argument of 'shape' intrinsic at %L must not be "
1528 "an assumed size array", &source->where);
1537 gfc_check_size (gfc_expr * array, gfc_expr * dim)
1540 if (array_check (array, 0) == FAILURE)
1545 if (type_check (dim, 1, BT_INTEGER) == FAILURE)
1548 if (kind_value_check (dim, 1, gfc_default_integer_kind) == FAILURE)
1551 if (dim_rank_check (dim, array, 0) == FAILURE)
1560 gfc_check_sign (gfc_expr * a, gfc_expr * b)
1563 if (int_or_real_check (a, 0) == FAILURE)
1566 if (same_type_check (a, 0, b, 1) == FAILURE)
1574 gfc_check_spread (gfc_expr * source, gfc_expr * dim, gfc_expr * ncopies)
1577 if (source->rank >= GFC_MAX_DIMENSIONS)
1579 must_be (source, 0, "less than rank " stringize (GFC_MAX_DIMENSIONS));
1583 if (dim_check (dim, 1, 0) == FAILURE)
1586 if (type_check (ncopies, 2, BT_INTEGER) == FAILURE)
1588 if (scalar_check (ncopies, 2) == FAILURE)
1596 gfc_check_transfer (gfc_expr * source ATTRIBUTE_UNUSED,
1597 gfc_expr * mold ATTRIBUTE_UNUSED,
1603 if (type_check (size, 2, BT_INTEGER) == FAILURE)
1606 if (scalar_check (size, 2) == FAILURE)
1609 if (nonoptional_check (size, 2) == FAILURE)
1618 gfc_check_transpose (gfc_expr * matrix)
1621 if (rank_check (matrix, 0, 2) == FAILURE)
1629 gfc_check_ubound (gfc_expr * array, gfc_expr * dim)
1632 if (array_check (array, 0) == FAILURE)
1637 if (dim_check (dim, 1, 1) == FAILURE)
1640 if (dim_rank_check (dim, array, 0) == FAILURE)
1648 gfc_check_unpack (gfc_expr * vector, gfc_expr * mask, gfc_expr * field)
1651 if (rank_check (vector, 0, 1) == FAILURE)
1654 if (array_check (mask, 1) == FAILURE)
1657 if (type_check (mask, 1, BT_LOGICAL) == FAILURE)
1660 if (same_type_check (vector, 0, field, 2) == FAILURE)
1668 gfc_check_verify (gfc_expr * x, gfc_expr * y, gfc_expr * z)
1671 if (type_check (x, 0, BT_CHARACTER) == FAILURE)
1674 if (same_type_check (x, 0, y, 1) == FAILURE)
1677 if (z != NULL && type_check (z, 2, BT_LOGICAL) == FAILURE)
1685 gfc_check_trim (gfc_expr * x)
1687 if (type_check (x, 0, BT_CHARACTER) == FAILURE)
1690 if (scalar_check (x, 0) == FAILURE)
1697 /* Common check function for the half a dozen intrinsics that have a
1698 single real argument. */
1701 gfc_check_x (gfc_expr * x)
1704 if (type_check (x, 0, BT_REAL) == FAILURE)
1711 /************* Check functions for intrinsic subroutines *************/
1714 gfc_check_cpu_time (gfc_expr * time)
1717 if (scalar_check (time, 0) == FAILURE)
1720 if (type_check (time, 0, BT_REAL) == FAILURE)
1723 if (variable_check (time, 0) == FAILURE)
1731 gfc_check_date_and_time (gfc_expr * date, gfc_expr * time,
1732 gfc_expr * zone, gfc_expr * values)
1737 if (type_check (date, 0, BT_CHARACTER) == FAILURE)
1739 if (scalar_check (date, 0) == FAILURE)
1741 if (variable_check (date, 0) == FAILURE)
1747 if (type_check (time, 1, BT_CHARACTER) == FAILURE)
1749 if (scalar_check (time, 1) == FAILURE)
1751 if (variable_check (time, 1) == FAILURE)
1757 if (type_check (zone, 2, BT_CHARACTER) == FAILURE)
1759 if (scalar_check (zone, 2) == FAILURE)
1761 if (variable_check (zone, 2) == FAILURE)
1767 if (type_check (values, 3, BT_INTEGER) == FAILURE)
1769 if (array_check (values, 3) == FAILURE)
1771 if (rank_check (values, 3, 1) == FAILURE)
1773 if (variable_check (values, 3) == FAILURE)
1782 gfc_check_mvbits (gfc_expr * from, gfc_expr * frompos, gfc_expr * len,
1783 gfc_expr * to, gfc_expr * topos)
1786 if (type_check (from, 0, BT_INTEGER) == FAILURE)
1789 if (type_check (frompos, 1, BT_INTEGER) == FAILURE)
1792 if (type_check (len, 2, BT_INTEGER) == FAILURE)
1795 if (same_type_check (from, 0, to, 3) == FAILURE)
1798 if (variable_check (to, 3) == FAILURE)
1801 if (type_check (topos, 4, BT_INTEGER) == FAILURE)
1809 gfc_check_random_number (gfc_expr * harvest)
1812 if (type_check (harvest, 0, BT_REAL) == FAILURE)
1815 if (variable_check (harvest, 0) == FAILURE)
1823 gfc_check_random_seed (gfc_expr * size, gfc_expr * put, gfc_expr * get)
1828 if (scalar_check (size, 0) == FAILURE)
1831 if (type_check (size, 0, BT_INTEGER) == FAILURE)
1834 if (variable_check (size, 0) == FAILURE)
1837 if (kind_value_check (size, 0, gfc_default_integer_kind) == FAILURE)
1845 gfc_error ("Too many arguments to %s at %L", gfc_current_intrinsic,
1848 if (array_check (put, 1) == FAILURE)
1851 if (rank_check (put, 1, 1) == FAILURE)
1854 if (type_check (put, 1, BT_INTEGER) == FAILURE)
1857 if (kind_value_check (put, 1, gfc_default_integer_kind) == FAILURE)
1864 if (size != NULL || put != NULL)
1865 gfc_error ("Too many arguments to %s at %L", gfc_current_intrinsic,
1868 if (array_check (get, 2) == FAILURE)
1871 if (rank_check (get, 2, 1) == FAILURE)
1874 if (type_check (get, 2, BT_INTEGER) == FAILURE)
1877 if (variable_check (get, 2) == FAILURE)
1880 if (kind_value_check (get, 2, gfc_default_integer_kind) == FAILURE)
1888 gfc_check_second_sub (gfc_expr * time)
1891 if (scalar_check (time, 0) == FAILURE)
1894 if (type_check (time, 0, BT_REAL) == FAILURE)
1897 if (kind_value_check(time, 0, 4) == FAILURE)
1904 /* The arguments of SYSTEM_CLOCK are scalar, integer variables. Note,
1905 count, count_rate, and count_max are all optional arguments */
1908 gfc_check_system_clock (gfc_expr * count, gfc_expr * count_rate,
1909 gfc_expr * count_max)
1914 if (scalar_check (count, 0) == FAILURE)
1917 if (type_check (count, 0, BT_INTEGER) == FAILURE)
1920 if (variable_check (count, 0) == FAILURE)
1924 if (count_rate != NULL)
1926 if (scalar_check (count_rate, 1) == FAILURE)
1929 if (type_check (count_rate, 1, BT_INTEGER) == FAILURE)
1932 if (variable_check (count_rate, 1) == FAILURE)
1935 if (count != NULL && same_type_check(count, 0, count_rate, 1) == FAILURE)
1940 if (count_max != NULL)
1942 if (scalar_check (count_max, 2) == FAILURE)
1945 if (type_check (count_max, 2, BT_INTEGER) == FAILURE)
1948 if (variable_check (count_max, 2) == FAILURE)
1951 if (count != NULL && same_type_check(count, 0, count_max, 2) == FAILURE)
1954 if (count_rate != NULL
1955 && same_type_check(count_rate, 1, count_max, 2) == FAILURE)
1964 gfc_check_irand (gfc_expr * x)
1966 if (scalar_check (x, 0) == FAILURE)
1969 if (type_check (x, 0, BT_INTEGER) == FAILURE)
1972 if (kind_value_check(x, 0, 4) == FAILURE)
1979 gfc_check_rand (gfc_expr * x)
1981 if (scalar_check (x, 0) == FAILURE)
1984 if (type_check (x, 0, BT_INTEGER) == FAILURE)
1987 if (kind_value_check(x, 0, 4) == FAILURE)
1994 gfc_check_srand (gfc_expr * x)
1996 if (scalar_check (x, 0) == FAILURE)
1999 if (type_check (x, 0, BT_INTEGER) == FAILURE)
2002 if (kind_value_check(x, 0, 4) == FAILURE)
2009 gfc_check_etime (gfc_expr * x)
2011 if (array_check (x, 0) == FAILURE)
2014 if (rank_check (x, 0, 1) == FAILURE)
2017 if (variable_check (x, 0) == FAILURE)
2020 if (type_check (x, 0, BT_REAL) == FAILURE)
2023 if (kind_value_check(x, 0, 4) == FAILURE)
2030 gfc_check_etime_sub (gfc_expr * values, gfc_expr * time)
2032 if (array_check (values, 0) == FAILURE)
2035 if (rank_check (values, 0, 1) == FAILURE)
2038 if (variable_check (values, 0) == FAILURE)
2041 if (type_check (values, 0, BT_REAL) == FAILURE)
2044 if (kind_value_check(values, 0, 4) == FAILURE)
2047 if (scalar_check (time, 1) == FAILURE)
2050 if (type_check (time, 1, BT_REAL) == FAILURE)
2053 if (kind_value_check(time, 1, 4) == FAILURE)