1 /* Routines for manipulation of expression nodes.
2 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software
4 Contributed by Andy Vaught
6 This file is part of GCC.
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 2, or (at your option) any later
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
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
29 /* Get a new expr node. */
36 e = gfc_getmem (sizeof (gfc_expr));
38 gfc_clear_ts (&e->ts);
47 /* Free an argument list and everything below it. */
50 gfc_free_actual_arglist (gfc_actual_arglist * a1)
52 gfc_actual_arglist *a2;
57 gfc_free_expr (a1->expr);
64 /* Copy an arglist structure and all of the arguments. */
67 gfc_copy_actual_arglist (gfc_actual_arglist * p)
69 gfc_actual_arglist *head, *tail, *new;
73 for (; p; p = p->next)
75 new = gfc_get_actual_arglist ();
78 new->expr = gfc_copy_expr (p->expr);
93 /* Free a list of reference structures. */
96 gfc_free_ref_list (gfc_ref * p)
108 for (i = 0; i < GFC_MAX_DIMENSIONS; i++)
110 gfc_free_expr (p->u.ar.start[i]);
111 gfc_free_expr (p->u.ar.end[i]);
112 gfc_free_expr (p->u.ar.stride[i]);
118 gfc_free_expr (p->u.ss.start);
119 gfc_free_expr (p->u.ss.end);
131 /* Workhorse function for gfc_free_expr() that frees everything
132 beneath an expression node, but not the node itself. This is
133 useful when we want to simplify a node and replace it with
134 something else or the expression node belongs to another structure. */
137 free_expr0 (gfc_expr * e)
141 switch (e->expr_type)
146 gfc_free (e->value.character.string);
153 mpz_clear (e->value.integer);
157 mpfr_clear (e->value.real);
162 gfc_free (e->value.character.string);
166 mpfr_clear (e->value.complex.r);
167 mpfr_clear (e->value.complex.i);
177 if (e->value.op.op1 != NULL)
178 gfc_free_expr (e->value.op.op1);
179 if (e->value.op.op2 != NULL)
180 gfc_free_expr (e->value.op.op2);
184 gfc_free_actual_arglist (e->value.function.actual);
192 gfc_free_constructor (e->value.constructor);
196 gfc_free (e->value.character.string);
203 gfc_internal_error ("free_expr0(): Bad expr type");
206 /* Free a shape array. */
207 if (e->shape != NULL)
209 for (n = 0; n < e->rank; n++)
210 mpz_clear (e->shape[n]);
215 gfc_free_ref_list (e->ref);
217 memset (e, '\0', sizeof (gfc_expr));
221 /* Free an expression node and everything beneath it. */
224 gfc_free_expr (gfc_expr * e)
235 /* Graft the *src expression onto the *dest subexpression. */
238 gfc_replace_expr (gfc_expr * dest, gfc_expr * src)
248 /* Try to extract an integer constant from the passed expression node.
249 Returns an error message or NULL if the result is set. It is
250 tempting to generate an error and return SUCCESS or FAILURE, but
251 failure is OK for some callers. */
254 gfc_extract_int (gfc_expr * expr, int *result)
257 if (expr->expr_type != EXPR_CONSTANT)
258 return _("Constant expression required at %C");
260 if (expr->ts.type != BT_INTEGER)
261 return _("Integer expression required at %C");
263 if ((mpz_cmp_si (expr->value.integer, INT_MAX) > 0)
264 || (mpz_cmp_si (expr->value.integer, INT_MIN) < 0))
266 return _("Integer value too large in expression at %C");
269 *result = (int) mpz_get_si (expr->value.integer);
275 /* Recursively copy a list of reference structures. */
278 copy_ref (gfc_ref * src)
286 dest = gfc_get_ref ();
287 dest->type = src->type;
292 ar = gfc_copy_array_ref (&src->u.ar);
298 dest->u.c = src->u.c;
302 dest->u.ss = src->u.ss;
303 dest->u.ss.start = gfc_copy_expr (src->u.ss.start);
304 dest->u.ss.end = gfc_copy_expr (src->u.ss.end);
308 dest->next = copy_ref (src->next);
314 /* Detect whether an expression has any vector index array
318 gfc_has_vector_index (gfc_expr *e)
322 for (ref = e->ref; ref; ref = ref->next)
323 if (ref->type == REF_ARRAY)
324 for (i = 0; i < ref->u.ar.dimen; i++)
325 if (ref->u.ar.dimen_type[i] == DIMEN_VECTOR)
331 /* Copy a shape array. */
334 gfc_copy_shape (mpz_t * shape, int rank)
342 new_shape = gfc_get_shape (rank);
344 for (n = 0; n < rank; n++)
345 mpz_init_set (new_shape[n], shape[n]);
351 /* Copy a shape array excluding dimension N, where N is an integer
352 constant expression. Dimensions are numbered in fortran style --
355 So, if the original shape array contains R elements
356 { s1 ... sN-1 sN sN+1 ... sR-1 sR}
357 the result contains R-1 elements:
358 { s1 ... sN-1 sN+1 ... sR-1}
360 If anything goes wrong -- N is not a constant, its value is out
361 of range -- or anything else, just returns NULL.
365 gfc_copy_shape_excluding (mpz_t * shape, int rank, gfc_expr * dim)
367 mpz_t *new_shape, *s;
373 || dim->expr_type != EXPR_CONSTANT
374 || dim->ts.type != BT_INTEGER)
377 n = mpz_get_si (dim->value.integer);
378 n--; /* Convert to zero based index */
379 if (n < 0 || n >= rank)
382 s = new_shape = gfc_get_shape (rank-1);
384 for (i = 0; i < rank; i++)
388 mpz_init_set (*s, shape[i]);
395 /* Given an expression pointer, return a copy of the expression. This
396 subroutine is recursive. */
399 gfc_copy_expr (gfc_expr * p)
410 switch (q->expr_type)
413 s = gfc_getmem (p->value.character.length + 1);
414 q->value.character.string = s;
416 memcpy (s, p->value.character.string, p->value.character.length + 1);
422 s = gfc_getmem (p->value.character.length + 1);
423 q->value.character.string = s;
425 memcpy (s, p->value.character.string,
426 p->value.character.length + 1);
432 mpz_init_set (q->value.integer, p->value.integer);
436 gfc_set_model_kind (q->ts.kind);
437 mpfr_init (q->value.real);
438 mpfr_set (q->value.real, p->value.real, GFC_RND_MODE);
442 gfc_set_model_kind (q->ts.kind);
443 mpfr_init (q->value.complex.r);
444 mpfr_init (q->value.complex.i);
445 mpfr_set (q->value.complex.r, p->value.complex.r, GFC_RND_MODE);
446 mpfr_set (q->value.complex.i, p->value.complex.i, GFC_RND_MODE);
451 s = gfc_getmem (p->value.character.length + 1);
452 q->value.character.string = s;
454 memcpy (s, p->value.character.string,
455 p->value.character.length + 1);
460 break; /* Already done */
464 gfc_internal_error ("gfc_copy_expr(): Bad expr node");
471 switch (q->value.op.operator)
474 case INTRINSIC_UPLUS:
475 case INTRINSIC_UMINUS:
476 q->value.op.op1 = gfc_copy_expr (p->value.op.op1);
479 default: /* Binary operators */
480 q->value.op.op1 = gfc_copy_expr (p->value.op.op1);
481 q->value.op.op2 = gfc_copy_expr (p->value.op.op2);
488 q->value.function.actual =
489 gfc_copy_actual_arglist (p->value.function.actual);
494 q->value.constructor = gfc_copy_constructor (p->value.constructor);
502 q->shape = gfc_copy_shape (p->shape, p->rank);
504 q->ref = copy_ref (p->ref);
510 /* Return the maximum kind of two expressions. In general, higher
511 kind numbers mean more precision for numeric types. */
514 gfc_kind_max (gfc_expr * e1, gfc_expr * e2)
517 return (e1->ts.kind > e2->ts.kind) ? e1->ts.kind : e2->ts.kind;
521 /* Returns nonzero if the type is numeric, zero otherwise. */
524 numeric_type (bt type)
527 return type == BT_COMPLEX || type == BT_REAL || type == BT_INTEGER;
531 /* Returns nonzero if the typespec is a numeric type, zero otherwise. */
534 gfc_numeric_ts (gfc_typespec * ts)
537 return numeric_type (ts->type);
541 /* Returns an expression node that is an integer constant. */
550 p->expr_type = EXPR_CONSTANT;
551 p->ts.type = BT_INTEGER;
552 p->ts.kind = gfc_default_integer_kind;
554 p->where = gfc_current_locus;
555 mpz_init_set_si (p->value.integer, i);
561 /* Returns an expression node that is a logical constant. */
564 gfc_logical_expr (int i, locus * where)
570 p->expr_type = EXPR_CONSTANT;
571 p->ts.type = BT_LOGICAL;
572 p->ts.kind = gfc_default_logical_kind;
575 where = &gfc_current_locus;
577 p->value.logical = i;
583 /* Return an expression node with an optional argument list attached.
584 A variable number of gfc_expr pointers are strung together in an
585 argument list with a NULL pointer terminating the list. */
588 gfc_build_conversion (gfc_expr * e)
593 p->expr_type = EXPR_FUNCTION;
595 p->value.function.actual = NULL;
597 p->value.function.actual = gfc_get_actual_arglist ();
598 p->value.function.actual->expr = e;
604 /* Given an expression node with some sort of numeric binary
605 expression, insert type conversions required to make the operands
608 The exception is that the operands of an exponential don't have to
609 have the same type. If possible, the base is promoted to the type
610 of the exponent. For example, 1**2.3 becomes 1.0**2.3, but
611 1.0**2 stays as it is. */
614 gfc_type_convert_binary (gfc_expr * e)
618 op1 = e->value.op.op1;
619 op2 = e->value.op.op2;
621 if (op1->ts.type == BT_UNKNOWN || op2->ts.type == BT_UNKNOWN)
623 gfc_clear_ts (&e->ts);
627 /* Kind conversions of same type. */
628 if (op1->ts.type == op2->ts.type)
631 if (op1->ts.kind == op2->ts.kind)
633 /* No type conversions. */
638 if (op1->ts.kind > op2->ts.kind)
639 gfc_convert_type (op2, &op1->ts, 2);
641 gfc_convert_type (op1, &op2->ts, 2);
647 /* Integer combined with real or complex. */
648 if (op2->ts.type == BT_INTEGER)
652 /* Special case for ** operator. */
653 if (e->value.op.operator == INTRINSIC_POWER)
656 gfc_convert_type (e->value.op.op2, &e->ts, 2);
660 if (op1->ts.type == BT_INTEGER)
663 gfc_convert_type (e->value.op.op1, &e->ts, 2);
667 /* Real combined with complex. */
668 e->ts.type = BT_COMPLEX;
669 if (op1->ts.kind > op2->ts.kind)
670 e->ts.kind = op1->ts.kind;
672 e->ts.kind = op2->ts.kind;
673 if (op1->ts.type != BT_COMPLEX || op1->ts.kind != e->ts.kind)
674 gfc_convert_type (e->value.op.op1, &e->ts, 2);
675 if (op2->ts.type != BT_COMPLEX || op2->ts.kind != e->ts.kind)
676 gfc_convert_type (e->value.op.op2, &e->ts, 2);
683 /* Function to determine if an expression is constant or not. This
684 function expects that the expression has already been simplified. */
687 gfc_is_constant_expr (gfc_expr * e)
690 gfc_actual_arglist *arg;
696 switch (e->expr_type)
699 rv = (gfc_is_constant_expr (e->value.op.op1)
700 && (e->value.op.op2 == NULL
701 || gfc_is_constant_expr (e->value.op.op2)));
710 /* Call to intrinsic with at least one argument. */
712 if (e->value.function.isym && e->value.function.actual)
714 for (arg = e->value.function.actual; arg; arg = arg->next)
716 if (!gfc_is_constant_expr (arg->expr))
730 rv = (gfc_is_constant_expr (e->ref->u.ss.start)
731 && gfc_is_constant_expr (e->ref->u.ss.end));
736 for (c = e->value.constructor; c; c = c->next)
737 if (!gfc_is_constant_expr (c->expr))
745 rv = gfc_constant_ac (e);
749 gfc_internal_error ("gfc_is_constant_expr(): Unknown expression type");
756 /* Try to collapse intrinsic expressions. */
759 simplify_intrinsic_op (gfc_expr * p, int type)
761 gfc_expr *op1, *op2, *result;
763 if (p->value.op.operator == INTRINSIC_USER)
766 op1 = p->value.op.op1;
767 op2 = p->value.op.op2;
769 if (gfc_simplify_expr (op1, type) == FAILURE)
771 if (gfc_simplify_expr (op2, type) == FAILURE)
774 if (!gfc_is_constant_expr (op1)
775 || (op2 != NULL && !gfc_is_constant_expr (op2)))
779 p->value.op.op1 = NULL;
780 p->value.op.op2 = NULL;
782 switch (p->value.op.operator)
784 case INTRINSIC_UPLUS:
785 case INTRINSIC_PARENTHESES:
786 result = gfc_uplus (op1);
789 case INTRINSIC_UMINUS:
790 result = gfc_uminus (op1);
794 result = gfc_add (op1, op2);
797 case INTRINSIC_MINUS:
798 result = gfc_subtract (op1, op2);
801 case INTRINSIC_TIMES:
802 result = gfc_multiply (op1, op2);
805 case INTRINSIC_DIVIDE:
806 result = gfc_divide (op1, op2);
809 case INTRINSIC_POWER:
810 result = gfc_power (op1, op2);
813 case INTRINSIC_CONCAT:
814 result = gfc_concat (op1, op2);
818 result = gfc_eq (op1, op2);
822 result = gfc_ne (op1, op2);
826 result = gfc_gt (op1, op2);
830 result = gfc_ge (op1, op2);
834 result = gfc_lt (op1, op2);
838 result = gfc_le (op1, op2);
842 result = gfc_not (op1);
846 result = gfc_and (op1, op2);
850 result = gfc_or (op1, op2);
854 result = gfc_eqv (op1, op2);
858 result = gfc_neqv (op1, op2);
862 gfc_internal_error ("simplify_intrinsic_op(): Bad operator");
872 result->rank = p->rank;
873 result->where = p->where;
874 gfc_replace_expr (p, result);
880 /* Subroutine to simplify constructor expressions. Mutually recursive
881 with gfc_simplify_expr(). */
884 simplify_constructor (gfc_constructor * c, int type)
887 for (; c; c = c->next)
890 && (gfc_simplify_expr (c->iterator->start, type) == FAILURE
891 || gfc_simplify_expr (c->iterator->end, type) == FAILURE
892 || gfc_simplify_expr (c->iterator->step, type) == FAILURE))
895 if (c->expr && gfc_simplify_expr (c->expr, type) == FAILURE)
903 /* Pull a single array element out of an array constructor. */
906 find_array_element (gfc_constructor * cons, gfc_array_ref * ar,
907 gfc_constructor ** rval)
909 unsigned long nelemen;
919 mpz_init_set_ui (offset, 0);
921 for (i = 0; i < ar->dimen; i++)
923 e = gfc_copy_expr (ar->start[i]);
924 if (e->expr_type != EXPR_CONSTANT)
930 /* Check the bounds. */
932 && (mpz_cmp (e->value.integer,
933 ar->as->upper[i]->value.integer) > 0
934 || mpz_cmp (e->value.integer,
935 ar->as->lower[i]->value.integer) < 0))
937 gfc_error ("index in dimension %d is out of bounds "
938 "at %L", i + 1, &ar->c_where[i]);
944 mpz_sub (delta, e->value.integer,
945 ar->as->lower[i]->value.integer);
946 mpz_add (offset, offset, delta);
951 for (nelemen = mpz_get_ui (offset); nelemen > 0; nelemen--)
972 /* Find a component of a structure constructor. */
974 static gfc_constructor *
975 find_component_ref (gfc_constructor * cons, gfc_ref * ref)
980 comp = ref->u.c.sym->components;
981 pick = ref->u.c.component;
992 /* Replace an expression with the contents of a constructor, removing
993 the subobject reference in the process. */
996 remove_subobject_ref (gfc_expr * p, gfc_constructor * cons)
1002 e->ref = p->ref->next;
1003 p->ref->next = NULL;
1004 gfc_replace_expr (p, e);
1008 /* Pull an array section out of an array constructor. */
1011 find_array_section (gfc_expr *expr, gfc_ref *ref)
1017 long unsigned one = 1;
1019 mpz_t start[GFC_MAX_DIMENSIONS];
1020 mpz_t end[GFC_MAX_DIMENSIONS];
1021 mpz_t stride[GFC_MAX_DIMENSIONS];
1022 mpz_t delta[GFC_MAX_DIMENSIONS];
1023 mpz_t ctr[GFC_MAX_DIMENSIONS];
1029 gfc_constructor *cons;
1030 gfc_constructor *base;
1036 gfc_constructor *vecsub[GFC_MAX_DIMENSIONS], *c;
1041 base = expr->value.constructor;
1042 expr->value.constructor = NULL;
1044 rank = ref->u.ar.as->rank;
1046 if (expr->shape == NULL)
1047 expr->shape = gfc_get_shape (rank);
1049 mpz_init_set_ui (delta_mpz, one);
1050 mpz_init_set_ui (nelts, one);
1053 /* Do the initialization now, so that we can cleanup without
1054 keeping track of where we were. */
1055 for (d = 0; d < rank; d++)
1057 mpz_init (delta[d]);
1058 mpz_init (start[d]);
1061 mpz_init (stride[d]);
1065 /* Build the counters to clock through the array reference. */
1067 for (d = 0; d < rank; d++)
1069 /* Make this stretch of code easier on the eye! */
1070 begin = ref->u.ar.start[d];
1071 finish = ref->u.ar.end[d];
1072 step = ref->u.ar.stride[d];
1073 lower = ref->u.ar.as->lower[d];
1074 upper = ref->u.ar.as->upper[d];
1076 if (ref->u.ar.dimen_type[d] == DIMEN_VECTOR) /* Vector subscript. */
1079 gcc_assert(begin->expr_type == EXPR_ARRAY);
1080 gcc_assert(begin->rank == 1);
1081 gcc_assert(begin->shape);
1083 vecsub[d] = begin->value.constructor;
1084 mpz_set (ctr[d], vecsub[d]->expr->value.integer);
1085 mpz_mul (nelts, nelts, begin->shape[0]);
1086 mpz_set (expr->shape[shape_i++], begin->shape[0]);
1089 for (c = vecsub[d]; c; c = c->next)
1091 if (mpz_cmp (c->expr->value.integer, upper->value.integer) > 0
1092 || mpz_cmp (c->expr->value.integer, lower->value.integer) < 0)
1094 gfc_error ("index in dimension %d is out of bounds "
1095 "at %L", d + 1, &ref->u.ar.c_where[d]);
1103 if ((begin && begin->expr_type != EXPR_CONSTANT)
1104 || (finish && finish->expr_type != EXPR_CONSTANT)
1105 || (step && step->expr_type != EXPR_CONSTANT))
1111 /* Obtain the stride. */
1113 mpz_set (stride[d], step->value.integer);
1115 mpz_set_ui (stride[d], one);
1117 if (mpz_cmp_ui (stride[d], 0) == 0)
1118 mpz_set_ui (stride[d], one);
1120 /* Obtain the start value for the index. */
1122 mpz_set (start[d], begin->value.integer);
1124 mpz_set (start[d], lower->value.integer);
1126 mpz_set (ctr[d], start[d]);
1128 /* Obtain the end value for the index. */
1130 mpz_set (end[d], finish->value.integer);
1132 mpz_set (end[d], upper->value.integer);
1134 /* Separate 'if' because elements sometimes arrive with
1136 if (ref->u.ar.dimen_type[d] == DIMEN_ELEMENT)
1137 mpz_set (end [d], begin->value.integer);
1139 /* Check the bounds. */
1140 if (mpz_cmp (ctr[d], upper->value.integer) > 0
1141 || mpz_cmp (end[d], upper->value.integer) > 0
1142 || mpz_cmp (ctr[d], lower->value.integer) < 0
1143 || mpz_cmp (end[d], lower->value.integer) < 0)
1145 gfc_error ("index in dimension %d is out of bounds "
1146 "at %L", d + 1, &ref->u.ar.c_where[d]);
1151 /* Calculate the number of elements and the shape. */
1152 mpz_abs (tmp_mpz, stride[d]);
1153 mpz_div (tmp_mpz, stride[d], tmp_mpz);
1154 mpz_add (tmp_mpz, end[d], tmp_mpz);
1155 mpz_sub (tmp_mpz, tmp_mpz, ctr[d]);
1156 mpz_div (tmp_mpz, tmp_mpz, stride[d]);
1157 mpz_mul (nelts, nelts, tmp_mpz);
1159 /* An element reference reduces the rank of the expression; don't add
1160 anything to the shape array. */
1161 if (ref->u.ar.dimen_type[d] != DIMEN_ELEMENT)
1162 mpz_set (expr->shape[shape_i++], tmp_mpz);
1165 /* Calculate the 'stride' (=delta) for conversion of the
1166 counter values into the index along the constructor. */
1167 mpz_set (delta[d], delta_mpz);
1168 mpz_sub (tmp_mpz, upper->value.integer, lower->value.integer);
1169 mpz_add_ui (tmp_mpz, tmp_mpz, one);
1170 mpz_mul (delta_mpz, delta_mpz, tmp_mpz);
1177 /* Now clock through the array reference, calculating the index in
1178 the source constructor and transferring the elements to the new
1180 for (idx = 0; idx < (int)mpz_get_si (nelts); idx++)
1182 if (ref->u.ar.offset)
1183 mpz_set (ptr, ref->u.ar.offset->value.integer);
1185 mpz_init_set_ui (ptr, 0);
1188 for (d = 0; d < rank; d++)
1190 mpz_set (tmp_mpz, ctr[d]);
1191 mpz_sub_ui (tmp_mpz, tmp_mpz, one);
1192 mpz_mul (tmp_mpz, tmp_mpz, delta[d]);
1193 mpz_add (ptr, ptr, tmp_mpz);
1195 if (!incr_ctr) continue;
1197 if (ref->u.ar.dimen_type[d] == DIMEN_VECTOR) /* Vector subscript. */
1199 gcc_assert(vecsub[d]);
1201 if (!vecsub[d]->next)
1202 vecsub[d] = ref->u.ar.start[d]->value.constructor;
1205 vecsub[d] = vecsub[d]->next;
1208 mpz_set (ctr[d], vecsub[d]->expr->value.integer);
1212 mpz_add (ctr[d], ctr[d], stride[d]);
1214 if (mpz_cmp_ui (stride[d], 0) > 0 ?
1215 mpz_cmp (ctr[d], end[d]) > 0 :
1216 mpz_cmp (ctr[d], end[d]) < 0)
1217 mpz_set (ctr[d], start[d]);
1223 /* There must be a better way of dealing with negative strides
1224 than resetting the index and the constructor pointer! */
1225 if (mpz_cmp (ptr, index) < 0)
1227 mpz_set_ui (index, 0);
1231 while (mpz_cmp (ptr, index) > 0)
1233 mpz_add_ui (index, index, one);
1237 gfc_append_constructor (expr, gfc_copy_expr (cons->expr));
1245 mpz_clear (delta_mpz);
1246 mpz_clear (tmp_mpz);
1248 for (d = 0; d < rank; d++)
1250 mpz_clear (delta[d]);
1251 mpz_clear (start[d]);
1254 mpz_clear (stride[d]);
1256 gfc_free_constructor (base);
1260 /* Pull a substring out of an expression. */
1263 find_substring_ref (gfc_expr *p, gfc_expr **newp)
1269 if (p->ref->u.ss.start->expr_type != EXPR_CONSTANT
1270 || p->ref->u.ss.end->expr_type != EXPR_CONSTANT)
1273 *newp = gfc_copy_expr (p);
1274 chr = p->value.character.string;
1275 end = (int)mpz_get_ui (p->ref->u.ss.end->value.integer);
1276 start = (int)mpz_get_ui (p->ref->u.ss.start->value.integer);
1278 (*newp)->value.character.length = end - start + 1;
1279 strncpy ((*newp)->value.character.string, &chr[start - 1],
1280 (*newp)->value.character.length);
1286 /* Simplify a subobject reference of a constructor. This occurs when
1287 parameter variable values are substituted. */
1290 simplify_const_ref (gfc_expr * p)
1292 gfc_constructor *cons;
1297 switch (p->ref->type)
1300 switch (p->ref->u.ar.type)
1303 if (find_array_element (p->value.constructor,
1311 remove_subobject_ref (p, cons);
1315 if (find_array_section (p, p->ref) == FAILURE)
1317 p->ref->u.ar.type = AR_FULL;
1322 if (p->ref->next != NULL
1323 && (p->ts.type == BT_CHARACTER || p->ts.type == BT_DERIVED))
1325 cons = p->value.constructor;
1326 for (; cons; cons = cons->next)
1328 cons->expr->ref = copy_ref (p->ref->next);
1329 simplify_const_ref (cons->expr);
1332 gfc_free_ref_list (p->ref);
1343 cons = find_component_ref (p->value.constructor, p->ref);
1344 remove_subobject_ref (p, cons);
1348 if (find_substring_ref (p, &newp) == FAILURE)
1351 gfc_replace_expr (p, newp);
1352 gfc_free_ref_list (p->ref);
1362 /* Simplify a chain of references. */
1365 simplify_ref_chain (gfc_ref * ref, int type)
1369 for (; ref; ref = ref->next)
1374 for (n = 0; n < ref->u.ar.dimen; n++)
1376 if (gfc_simplify_expr (ref->u.ar.start[n], type)
1379 if (gfc_simplify_expr (ref->u.ar.end[n], type)
1382 if (gfc_simplify_expr (ref->u.ar.stride[n], type)
1390 if (gfc_simplify_expr (ref->u.ss.start, type) == FAILURE)
1392 if (gfc_simplify_expr (ref->u.ss.end, type) == FAILURE)
1404 /* Try to substitute the value of a parameter variable. */
1406 simplify_parameter_variable (gfc_expr * p, int type)
1411 e = gfc_copy_expr (p->symtree->n.sym->value);
1417 /* Do not copy subobject refs for constant. */
1418 if (e->expr_type != EXPR_CONSTANT && p->ref != NULL)
1419 e->ref = copy_ref (p->ref);
1420 t = gfc_simplify_expr (e, type);
1422 /* Only use the simplification if it eliminated all subobject
1424 if (t == SUCCESS && ! e->ref)
1425 gfc_replace_expr (p, e);
1432 /* Given an expression, simplify it by collapsing constant
1433 expressions. Most simplification takes place when the expression
1434 tree is being constructed. If an intrinsic function is simplified
1435 at some point, we get called again to collapse the result against
1438 We work by recursively simplifying expression nodes, simplifying
1439 intrinsic functions where possible, which can lead to further
1440 constant collapsing. If an operator has constant operand(s), we
1441 rip the expression apart, and rebuild it, hoping that it becomes
1444 The expression type is defined for:
1445 0 Basic expression parsing
1446 1 Simplifying array constructors -- will substitute
1448 Returns FAILURE on error, SUCCESS otherwise.
1449 NOTE: Will return SUCCESS even if the expression can not be simplified. */
1452 gfc_simplify_expr (gfc_expr * p, int type)
1454 gfc_actual_arglist *ap;
1459 switch (p->expr_type)
1466 for (ap = p->value.function.actual; ap; ap = ap->next)
1467 if (gfc_simplify_expr (ap->expr, type) == FAILURE)
1470 if (p->value.function.isym != NULL
1471 && gfc_intrinsic_func_interface (p, 1) == MATCH_ERROR)
1476 case EXPR_SUBSTRING:
1477 if (simplify_ref_chain (p->ref, type) == FAILURE)
1480 if (gfc_is_constant_expr (p))
1485 gfc_extract_int (p->ref->u.ss.start, &start);
1486 start--; /* Convert from one-based to zero-based. */
1487 gfc_extract_int (p->ref->u.ss.end, &end);
1488 s = gfc_getmem (end - start + 2);
1489 memcpy (s, p->value.character.string + start, end - start);
1490 s[end-start+1] = '\0'; /* TODO: C-style string for debugging. */
1491 gfc_free (p->value.character.string);
1492 p->value.character.string = s;
1493 p->value.character.length = end - start;
1494 p->ts.cl = gfc_get_charlen ();
1495 p->ts.cl->next = gfc_current_ns->cl_list;
1496 gfc_current_ns->cl_list = p->ts.cl;
1497 p->ts.cl->length = gfc_int_expr (p->value.character.length);
1498 gfc_free_ref_list (p->ref);
1500 p->expr_type = EXPR_CONSTANT;
1505 if (simplify_intrinsic_op (p, type) == FAILURE)
1510 /* Only substitute array parameter variables if we are in an
1511 initialization expression, or we want a subsection. */
1512 if (p->symtree->n.sym->attr.flavor == FL_PARAMETER
1513 && (gfc_init_expr || p->ref
1514 || p->symtree->n.sym->value->expr_type != EXPR_ARRAY))
1516 if (simplify_parameter_variable (p, type) == FAILURE)
1523 gfc_simplify_iterator_var (p);
1526 /* Simplify subcomponent references. */
1527 if (simplify_ref_chain (p->ref, type) == FAILURE)
1532 case EXPR_STRUCTURE:
1534 if (simplify_ref_chain (p->ref, type) == FAILURE)
1537 if (simplify_constructor (p->value.constructor, type) == FAILURE)
1540 if (p->expr_type == EXPR_ARRAY
1541 && p->ref && p->ref->type == REF_ARRAY
1542 && p->ref->u.ar.type == AR_FULL)
1543 gfc_expand_constructor (p);
1545 if (simplify_const_ref (p) == FAILURE)
1555 /* Returns the type of an expression with the exception that iterator
1556 variables are automatically integers no matter what else they may
1563 if (e->expr_type == EXPR_VARIABLE && gfc_check_iter_variable (e) == SUCCESS)
1570 /* Check an intrinsic arithmetic operation to see if it is consistent
1571 with some type of expression. */
1573 static try check_init_expr (gfc_expr *);
1576 check_intrinsic_op (gfc_expr * e, try (*check_function) (gfc_expr *))
1578 gfc_expr *op1 = e->value.op.op1;
1579 gfc_expr *op2 = e->value.op.op2;
1581 if ((*check_function) (op1) == FAILURE)
1584 switch (e->value.op.operator)
1586 case INTRINSIC_UPLUS:
1587 case INTRINSIC_UMINUS:
1588 if (!numeric_type (et0 (op1)))
1598 if ((*check_function) (op2) == FAILURE)
1601 if (!(et0 (op1) == BT_CHARACTER && et0 (op2) == BT_CHARACTER)
1602 && !(numeric_type (et0 (op1)) && numeric_type (et0 (op2))))
1604 gfc_error ("Numeric or CHARACTER operands are required in "
1605 "expression at %L", &e->where);
1610 case INTRINSIC_PLUS:
1611 case INTRINSIC_MINUS:
1612 case INTRINSIC_TIMES:
1613 case INTRINSIC_DIVIDE:
1614 case INTRINSIC_POWER:
1615 if ((*check_function) (op2) == FAILURE)
1618 if (!numeric_type (et0 (op1)) || !numeric_type (et0 (op2)))
1621 if (e->value.op.operator == INTRINSIC_POWER
1622 && check_function == check_init_expr && et0 (op2) != BT_INTEGER)
1624 gfc_error ("Exponent at %L must be INTEGER for an initialization "
1625 "expression", &op2->where);
1631 case INTRINSIC_CONCAT:
1632 if ((*check_function) (op2) == FAILURE)
1635 if (et0 (op1) != BT_CHARACTER || et0 (op2) != BT_CHARACTER)
1637 gfc_error ("Concatenation operator in expression at %L "
1638 "must have two CHARACTER operands", &op1->where);
1642 if (op1->ts.kind != op2->ts.kind)
1644 gfc_error ("Concat operator at %L must concatenate strings of the "
1645 "same kind", &e->where);
1652 if (et0 (op1) != BT_LOGICAL)
1654 gfc_error (".NOT. operator in expression at %L must have a LOGICAL "
1655 "operand", &op1->where);
1664 case INTRINSIC_NEQV:
1665 if ((*check_function) (op2) == FAILURE)
1668 if (et0 (op1) != BT_LOGICAL || et0 (op2) != BT_LOGICAL)
1670 gfc_error ("LOGICAL operands are required in expression at %L",
1677 case INTRINSIC_PARENTHESES:
1681 gfc_error ("Only intrinsic operators can be used in expression at %L",
1689 gfc_error ("Numeric operands are required in expression at %L", &e->where);
1696 /* Certain inquiry functions are specifically allowed to have variable
1697 arguments, which is an exception to the normal requirement that an
1698 initialization function have initialization arguments. We head off
1699 this problem here. */
1702 check_inquiry (gfc_expr * e, int not_restricted)
1706 /* FIXME: This should be moved into the intrinsic definitions,
1707 to eliminate this ugly hack. */
1708 static const char * const inquiry_function[] = {
1709 "digits", "epsilon", "huge", "kind", "len", "maxexponent", "minexponent",
1710 "precision", "radix", "range", "tiny", "bit_size", "size", "shape",
1711 "lbound", "ubound", NULL
1716 /* An undeclared parameter will get us here (PR25018). */
1717 if (e->symtree == NULL)
1720 name = e->symtree->n.sym->name;
1722 for (i = 0; inquiry_function[i]; i++)
1723 if (strcmp (inquiry_function[i], name) == 0)
1726 if (inquiry_function[i] == NULL)
1729 e = e->value.function.actual->expr;
1731 if (e == NULL || e->expr_type != EXPR_VARIABLE)
1734 /* At this point we have an inquiry function with a variable argument. The
1735 type of the variable might be undefined, but we need it now, because the
1736 arguments of these functions are allowed to be undefined. */
1738 if (e->ts.type == BT_UNKNOWN)
1740 if (e->symtree->n.sym->ts.type == BT_UNKNOWN
1741 && gfc_set_default_type (e->symtree->n.sym, 0, gfc_current_ns)
1745 e->ts = e->symtree->n.sym->ts;
1748 /* Assumed character length will not reduce to a constant expression
1749 with LEN, as required by the standard. */
1750 if (i == 4 && not_restricted
1751 && e->symtree->n.sym->ts.type == BT_CHARACTER
1752 && e->symtree->n.sym->ts.cl->length == NULL)
1753 gfc_notify_std (GFC_STD_GNU, "assumed character length "
1754 "variable '%s' in constant expression at %L",
1755 e->symtree->n.sym->name, &e->where);
1761 /* Verify that an expression is an initialization expression. A side
1762 effect is that the expression tree is reduced to a single constant
1763 node if all goes well. This would normally happen when the
1764 expression is constructed but function references are assumed to be
1765 intrinsics in the context of initialization expressions. If
1766 FAILURE is returned an error message has been generated. */
1769 check_init_expr (gfc_expr * e)
1771 gfc_actual_arglist *ap;
1778 switch (e->expr_type)
1781 t = check_intrinsic_op (e, check_init_expr);
1783 t = gfc_simplify_expr (e, 0);
1790 if (check_inquiry (e, 1) != SUCCESS)
1793 for (ap = e->value.function.actual; ap; ap = ap->next)
1794 if (check_init_expr (ap->expr) == FAILURE)
1803 m = gfc_intrinsic_func_interface (e, 0);
1806 gfc_error ("Function '%s' in initialization expression at %L "
1807 "must be an intrinsic function",
1808 e->symtree->n.sym->name, &e->where);
1819 if (gfc_check_iter_variable (e) == SUCCESS)
1822 if (e->symtree->n.sym->attr.flavor == FL_PARAMETER)
1824 t = simplify_parameter_variable (e, 0);
1828 gfc_error ("Parameter '%s' at %L has not been declared or is "
1829 "a variable, which does not reduce to a constant "
1830 "expression", e->symtree->n.sym->name, &e->where);
1839 case EXPR_SUBSTRING:
1840 t = check_init_expr (e->ref->u.ss.start);
1844 t = check_init_expr (e->ref->u.ss.end);
1846 t = gfc_simplify_expr (e, 0);
1850 case EXPR_STRUCTURE:
1851 t = gfc_check_constructor (e, check_init_expr);
1855 t = gfc_check_constructor (e, check_init_expr);
1859 t = gfc_expand_constructor (e);
1863 t = gfc_check_constructor_type (e);
1867 gfc_internal_error ("check_init_expr(): Unknown expression type");
1874 /* Match an initialization expression. We work by first matching an
1875 expression, then reducing it to a constant. */
1878 gfc_match_init_expr (gfc_expr ** result)
1884 m = gfc_match_expr (&expr);
1889 t = gfc_resolve_expr (expr);
1891 t = check_init_expr (expr);
1896 gfc_free_expr (expr);
1900 if (expr->expr_type == EXPR_ARRAY
1901 && (gfc_check_constructor_type (expr) == FAILURE
1902 || gfc_expand_constructor (expr) == FAILURE))
1904 gfc_free_expr (expr);
1908 /* Not all inquiry functions are simplified to constant expressions
1909 so it is necessary to call check_inquiry again. */
1910 if (!gfc_is_constant_expr (expr)
1911 && check_inquiry (expr, 1) == FAILURE)
1913 gfc_error ("Initialization expression didn't reduce %C");
1924 static try check_restricted (gfc_expr *);
1926 /* Given an actual argument list, test to see that each argument is a
1927 restricted expression and optionally if the expression type is
1928 integer or character. */
1931 restricted_args (gfc_actual_arglist * a)
1933 for (; a; a = a->next)
1935 if (check_restricted (a->expr) == FAILURE)
1943 /************* Restricted/specification expressions *************/
1946 /* Make sure a non-intrinsic function is a specification function. */
1949 external_spec_function (gfc_expr * e)
1953 f = e->value.function.esym;
1955 if (f->attr.proc == PROC_ST_FUNCTION)
1957 gfc_error ("Specification function '%s' at %L cannot be a statement "
1958 "function", f->name, &e->where);
1962 if (f->attr.proc == PROC_INTERNAL)
1964 gfc_error ("Specification function '%s' at %L cannot be an internal "
1965 "function", f->name, &e->where);
1969 if (!f->attr.pure && !f->attr.elemental)
1971 gfc_error ("Specification function '%s' at %L must be PURE", f->name,
1976 if (f->attr.recursive)
1978 gfc_error ("Specification function '%s' at %L cannot be RECURSIVE",
1979 f->name, &e->where);
1983 return restricted_args (e->value.function.actual);
1987 /* Check to see that a function reference to an intrinsic is a
1988 restricted expression. */
1991 restricted_intrinsic (gfc_expr * e)
1993 /* TODO: Check constraints on inquiry functions. 7.1.6.2 (7). */
1994 if (check_inquiry (e, 0) == SUCCESS)
1997 return restricted_args (e->value.function.actual);
2001 /* Verify that an expression is a restricted expression. Like its
2002 cousin check_init_expr(), an error message is generated if we
2006 check_restricted (gfc_expr * e)
2014 switch (e->expr_type)
2017 t = check_intrinsic_op (e, check_restricted);
2019 t = gfc_simplify_expr (e, 0);
2024 t = e->value.function.esym ?
2025 external_spec_function (e) : restricted_intrinsic (e);
2030 sym = e->symtree->n.sym;
2033 if (sym->attr.optional)
2035 gfc_error ("Dummy argument '%s' at %L cannot be OPTIONAL",
2036 sym->name, &e->where);
2040 if (sym->attr.intent == INTENT_OUT)
2042 gfc_error ("Dummy argument '%s' at %L cannot be INTENT(OUT)",
2043 sym->name, &e->where);
2047 /* gfc_is_formal_arg broadcasts that a formal argument list is being processed
2048 in resolve.c(resolve_formal_arglist). This is done so that host associated
2049 dummy array indices are accepted (PR23446). */
2050 if (sym->attr.in_common
2051 || sym->attr.use_assoc
2053 || sym->ns != gfc_current_ns
2054 || (sym->ns->proc_name != NULL
2055 && sym->ns->proc_name->attr.flavor == FL_MODULE)
2056 || gfc_is_formal_arg ())
2062 gfc_error ("Variable '%s' cannot appear in the expression at %L",
2063 sym->name, &e->where);
2072 case EXPR_SUBSTRING:
2073 t = gfc_specification_expr (e->ref->u.ss.start);
2077 t = gfc_specification_expr (e->ref->u.ss.end);
2079 t = gfc_simplify_expr (e, 0);
2083 case EXPR_STRUCTURE:
2084 t = gfc_check_constructor (e, check_restricted);
2088 t = gfc_check_constructor (e, check_restricted);
2092 gfc_internal_error ("check_restricted(): Unknown expression type");
2099 /* Check to see that an expression is a specification expression. If
2100 we return FAILURE, an error has been generated. */
2103 gfc_specification_expr (gfc_expr * e)
2108 if (e->ts.type != BT_INTEGER)
2110 gfc_error ("Expression at %L must be of INTEGER type", &e->where);
2116 gfc_error ("Expression at %L must be scalar", &e->where);
2120 if (gfc_simplify_expr (e, 0) == FAILURE)
2123 return check_restricted (e);
2127 /************** Expression conformance checks. *************/
2129 /* Given two expressions, make sure that the arrays are conformable. */
2132 gfc_check_conformance (const char *optype_msgid,
2133 gfc_expr * op1, gfc_expr * op2)
2135 int op1_flag, op2_flag, d;
2136 mpz_t op1_size, op2_size;
2139 if (op1->rank == 0 || op2->rank == 0)
2142 if (op1->rank != op2->rank)
2144 gfc_error ("Incompatible ranks in %s at %L", _(optype_msgid),
2151 for (d = 0; d < op1->rank; d++)
2153 op1_flag = gfc_array_dimen_size (op1, d, &op1_size) == SUCCESS;
2154 op2_flag = gfc_array_dimen_size (op2, d, &op2_size) == SUCCESS;
2156 if (op1_flag && op2_flag && mpz_cmp (op1_size, op2_size) != 0)
2158 gfc_error ("different shape for %s at %L on dimension %d (%d/%d)",
2159 _(optype_msgid), &op1->where, d + 1,
2160 (int) mpz_get_si (op1_size),
2161 (int) mpz_get_si (op2_size));
2167 mpz_clear (op1_size);
2169 mpz_clear (op2_size);
2179 /* Given an assignable expression and an arbitrary expression, make
2180 sure that the assignment can take place. */
2183 gfc_check_assign (gfc_expr * lvalue, gfc_expr * rvalue, int conform)
2187 sym = lvalue->symtree->n.sym;
2189 if (sym->attr.intent == INTENT_IN)
2191 gfc_error ("Can't assign to INTENT(IN) variable '%s' at %L",
2192 sym->name, &lvalue->where);
2196 /* 12.5.2.2, Note 12.26: The result variable is very similar to any other
2197 variable local to a function subprogram. Its existence begins when
2198 execution of the function is initiated and ends when execution of the
2199 function is terminated.....
2200 Therefore, the left hand side is no longer a varaiable, when it is:*/
2201 if (sym->attr.flavor == FL_PROCEDURE
2202 && sym->attr.proc != PROC_ST_FUNCTION
2203 && !sym->attr.external)
2208 /* (i) Use associated; */
2209 if (sym->attr.use_assoc)
2212 /* (ii) The assignment is in the main program; or */
2213 if (gfc_current_ns->proc_name->attr.is_main_program)
2216 /* (iii) A module or internal procedure.... */
2217 if ((gfc_current_ns->proc_name->attr.proc == PROC_INTERNAL
2218 || gfc_current_ns->proc_name->attr.proc == PROC_MODULE)
2219 && gfc_current_ns->parent
2220 && (!(gfc_current_ns->parent->proc_name->attr.function
2221 || gfc_current_ns->parent->proc_name->attr.subroutine)
2222 || gfc_current_ns->parent->proc_name->attr.is_main_program))
2224 /* .... that is not a function.... */
2225 if (!gfc_current_ns->proc_name->attr.function)
2228 /* .... or is not an entry and has a different name. */
2229 if (!sym->attr.entry && sym->name != gfc_current_ns->proc_name->name)
2235 gfc_error ("'%s' at %L is not a VALUE", sym->name, &lvalue->where);
2240 if (rvalue->rank != 0 && lvalue->rank != rvalue->rank)
2242 gfc_error ("Incompatible ranks %d and %d in assignment at %L",
2243 lvalue->rank, rvalue->rank, &lvalue->where);
2247 if (lvalue->ts.type == BT_UNKNOWN)
2249 gfc_error ("Variable type is UNKNOWN in assignment at %L",
2254 if (rvalue->expr_type == EXPR_NULL)
2256 gfc_error ("NULL appears on right-hand side in assignment at %L",
2261 if (sym->attr.cray_pointee
2262 && lvalue->ref != NULL
2263 && lvalue->ref->u.ar.type == AR_FULL
2264 && lvalue->ref->u.ar.as->cp_was_assumed)
2266 gfc_error ("Vector assignment to assumed-size Cray Pointee at %L"
2267 " is illegal.", &lvalue->where);
2271 /* This is possibly a typo: x = f() instead of x => f() */
2272 if (gfc_option.warn_surprising
2273 && rvalue->expr_type == EXPR_FUNCTION
2274 && rvalue->symtree->n.sym->attr.pointer)
2275 gfc_warning ("POINTER valued function appears on right-hand side of "
2276 "assignment at %L", &rvalue->where);
2278 /* Check size of array assignments. */
2279 if (lvalue->rank != 0 && rvalue->rank != 0
2280 && gfc_check_conformance ("Array assignment", lvalue, rvalue) != SUCCESS)
2283 if (gfc_compare_types (&lvalue->ts, &rvalue->ts))
2288 /* Numeric can be converted to any other numeric. And Hollerith can be
2289 converted to any other type. */
2290 if ((gfc_numeric_ts (&lvalue->ts) && gfc_numeric_ts (&rvalue->ts))
2291 || rvalue->ts.type == BT_HOLLERITH)
2294 if (lvalue->ts.type == BT_LOGICAL && rvalue->ts.type == BT_LOGICAL)
2297 gfc_error ("Incompatible types in assignment at %L, %s to %s",
2298 &rvalue->where, gfc_typename (&rvalue->ts),
2299 gfc_typename (&lvalue->ts));
2304 return gfc_convert_type (rvalue, &lvalue->ts, 1);
2308 /* Check that a pointer assignment is OK. We first check lvalue, and
2309 we only check rvalue if it's not an assignment to NULL() or a
2310 NULLIFY statement. */
2313 gfc_check_pointer_assign (gfc_expr * lvalue, gfc_expr * rvalue)
2315 symbol_attribute attr;
2318 if (lvalue->symtree->n.sym->ts.type == BT_UNKNOWN)
2320 gfc_error ("Pointer assignment target is not a POINTER at %L",
2325 if (lvalue->symtree->n.sym->attr.flavor == FL_PROCEDURE
2326 && lvalue->symtree->n.sym->attr.use_assoc)
2328 gfc_error ("'%s' in the pointer assignment at %L cannot be an "
2329 "l-value since it is a procedure",
2330 lvalue->symtree->n.sym->name, &lvalue->where);
2334 attr = gfc_variable_attr (lvalue, NULL);
2337 gfc_error ("Pointer assignment to non-POINTER at %L", &lvalue->where);
2341 is_pure = gfc_pure (NULL);
2343 if (is_pure && gfc_impure_variable (lvalue->symtree->n.sym))
2345 gfc_error ("Bad pointer object in PURE procedure at %L",
2350 /* If rvalue is a NULL() or NULLIFY, we're done. Otherwise the type,
2351 kind, etc for lvalue and rvalue must match, and rvalue must be a
2352 pure variable if we're in a pure function. */
2353 if (rvalue->expr_type == EXPR_NULL && rvalue->ts.type == BT_UNKNOWN)
2356 if (!gfc_compare_types (&lvalue->ts, &rvalue->ts))
2358 gfc_error ("Different types in pointer assignment at %L",
2363 if (lvalue->ts.kind != rvalue->ts.kind)
2365 gfc_error ("Different kind type parameters in pointer "
2366 "assignment at %L", &lvalue->where);
2370 if (lvalue->rank != rvalue->rank)
2372 gfc_error ("Different ranks in pointer assignment at %L",
2377 /* Now punt if we are dealing with a NULLIFY(X) or X = NULL(X). */
2378 if (rvalue->expr_type == EXPR_NULL)
2381 if (lvalue->ts.type == BT_CHARACTER
2382 && lvalue->ts.cl->length && rvalue->ts.cl->length
2383 && abs (gfc_dep_compare_expr (lvalue->ts.cl->length,
2384 rvalue->ts.cl->length)) == 1)
2386 gfc_error ("Different character lengths in pointer "
2387 "assignment at %L", &lvalue->where);
2391 attr = gfc_expr_attr (rvalue);
2392 if (!attr.target && !attr.pointer)
2394 gfc_error ("Pointer assignment target is neither TARGET "
2395 "nor POINTER at %L", &rvalue->where);
2399 if (is_pure && gfc_impure_variable (rvalue->symtree->n.sym))
2401 gfc_error ("Bad target in pointer assignment in PURE "
2402 "procedure at %L", &rvalue->where);
2405 if (gfc_has_vector_index (rvalue))
2407 gfc_error ("Pointer assignment with vector subscript "
2408 "on rhs at %L", &rvalue->where);
2416 /* Relative of gfc_check_assign() except that the lvalue is a single
2417 symbol. Used for initialization assignments. */
2420 gfc_check_assign_symbol (gfc_symbol * sym, gfc_expr * rvalue)
2425 memset (&lvalue, '\0', sizeof (gfc_expr));
2427 lvalue.expr_type = EXPR_VARIABLE;
2428 lvalue.ts = sym->ts;
2430 lvalue.rank = sym->as->rank;
2431 lvalue.symtree = (gfc_symtree *)gfc_getmem (sizeof (gfc_symtree));
2432 lvalue.symtree->n.sym = sym;
2433 lvalue.where = sym->declared_at;
2435 if (sym->attr.pointer)
2436 r = gfc_check_pointer_assign (&lvalue, rvalue);
2438 r = gfc_check_assign (&lvalue, rvalue, 1);
2440 gfc_free (lvalue.symtree);
2446 /* Get an expression for a default initializer. */
2449 gfc_default_initializer (gfc_typespec *ts)
2451 gfc_constructor *tail;
2457 /* See if we have a default initializer. */
2458 for (c = ts->derived->components; c; c = c->next)
2460 if ((c->initializer || c->allocatable) && init == NULL)
2461 init = gfc_get_expr ();
2467 /* Build the constructor. */
2468 init->expr_type = EXPR_STRUCTURE;
2470 init->where = ts->derived->declared_at;
2472 for (c = ts->derived->components; c; c = c->next)
2475 init->value.constructor = tail = gfc_get_constructor ();
2478 tail->next = gfc_get_constructor ();
2483 tail->expr = gfc_copy_expr (c->initializer);
2487 tail->expr = gfc_get_expr ();
2488 tail->expr->expr_type = EXPR_NULL;
2489 tail->expr->ts = c->ts;
2496 /* Given a symbol, create an expression node with that symbol as a
2497 variable. If the symbol is array valued, setup a reference of the
2501 gfc_get_variable_expr (gfc_symtree * var)
2505 e = gfc_get_expr ();
2506 e->expr_type = EXPR_VARIABLE;
2508 e->ts = var->n.sym->ts;
2510 if (var->n.sym->as != NULL)
2512 e->rank = var->n.sym->as->rank;
2513 e->ref = gfc_get_ref ();
2514 e->ref->type = REF_ARRAY;
2515 e->ref->u.ar.type = AR_FULL;
2522 /* Traverse expr, marking all EXPR_VARIABLE symbols referenced. */
2525 gfc_expr_set_symbols_referenced (gfc_expr * expr)
2527 gfc_actual_arglist *arg;
2534 switch (expr->expr_type)
2537 gfc_expr_set_symbols_referenced (expr->value.op.op1);
2538 gfc_expr_set_symbols_referenced (expr->value.op.op2);
2542 for (arg = expr->value.function.actual; arg; arg = arg->next)
2543 gfc_expr_set_symbols_referenced (arg->expr);
2547 gfc_set_sym_referenced (expr->symtree->n.sym);
2552 case EXPR_SUBSTRING:
2555 case EXPR_STRUCTURE:
2557 for (c = expr->value.constructor; c; c = c->next)
2558 gfc_expr_set_symbols_referenced (c->expr);
2566 for (ref = expr->ref; ref; ref = ref->next)
2570 for (i = 0; i < ref->u.ar.dimen; i++)
2572 gfc_expr_set_symbols_referenced (ref->u.ar.start[i]);
2573 gfc_expr_set_symbols_referenced (ref->u.ar.end[i]);
2574 gfc_expr_set_symbols_referenced (ref->u.ar.stride[i]);
2582 gfc_expr_set_symbols_referenced (ref->u.ss.start);
2583 gfc_expr_set_symbols_referenced (ref->u.ss.end);