1 /* Primary expression subroutines
2 Copyright (C) 2000, 2001, 2002, 2004 Free Software Foundation, Inc.
3 Contributed by Andy Vaught
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
34 /* Matches a kind-parameter expression, which is either a named
35 symbolic constant or a nonnegative integer constant. If
36 successful, sets the kind value to the correct integer. */
39 match_kind_param (int *kind
)
41 char name
[GFC_MAX_SYMBOL_LEN
+ 1];
46 m
= gfc_match_small_literal_int (kind
);
50 m
= gfc_match_name (name
);
54 if (gfc_find_symbol (name
, NULL
, 1, &sym
))
60 if (sym
->attr
.flavor
!= FL_PARAMETER
)
63 p
= gfc_extract_int (sym
->value
, kind
);
74 /* Get a trailing kind-specification for non-character variables.
76 the integer kind value or:
77 -1 if an error was generated
78 -2 if no kind was found */
86 if (gfc_match_char ('_') != MATCH_YES
)
89 m
= match_kind_param (&kind
);
91 gfc_error ("Missing kind-parameter at %C");
93 return (m
== MATCH_YES
) ? kind
: -1;
97 /* Given a character and a radix, see if the character is a valid
98 digit in that radix. */
101 check_digit (int c
, int radix
)
108 r
= ('0' <= c
&& c
<= '1');
112 r
= ('0' <= c
&& c
<= '7');
116 r
= ('0' <= c
&& c
<= '9');
120 r
= ('0' <= c
&& c
<= '9') || ('a' <= c
&& c
<= 'f');
124 gfc_internal_error ("check_digit(): bad radix");
131 /* Match the digit string part of an integer if signflag is not set,
132 the signed digit string part if signflag is set. If the buffer
133 is NULL, we just count characters for the resolution pass. Returns
134 the number of characters matched, -1 for no match. */
137 match_digits (int signflag
, int radix
, char *buffer
)
143 c
= gfc_next_char ();
145 if (signflag
&& (c
== '+' || c
== '-'))
149 c
= gfc_next_char ();
153 if (!check_digit (c
, radix
))
162 old_loc
= gfc_current_locus
;
163 c
= gfc_next_char ();
165 if (!check_digit (c
, radix
))
173 gfc_current_locus
= old_loc
;
179 /* Match an integer (digit string and optional kind).
180 A sign will be accepted if signflag is set. */
183 match_integer_constant (gfc_expr
** result
, int signflag
)
190 old_loc
= gfc_current_locus
;
191 gfc_gobble_whitespace ();
193 length
= match_digits (signflag
, 10, NULL
);
194 gfc_current_locus
= old_loc
;
198 buffer
= alloca (length
+ 1);
199 memset (buffer
, '\0', length
+ 1);
201 gfc_gobble_whitespace ();
203 match_digits (signflag
, 10, buffer
);
207 kind
= gfc_default_integer_kind
;
211 if (gfc_validate_kind (BT_INTEGER
, kind
, true) < 0)
213 gfc_error ("Integer kind %d at %C not available", kind
);
217 e
= gfc_convert_integer (buffer
, kind
, 10, &gfc_current_locus
);
219 if (gfc_range_check (e
) != ARITH_OK
)
221 gfc_error ("Integer too big for its kind at %C");
232 /* Match a binary, octal or hexadecimal constant that can be found in
236 match_boz_constant (gfc_expr
** result
)
238 int radix
, delim
, length
, x_hex
;
244 old_loc
= gfc_current_locus
;
245 gfc_gobble_whitespace ();
248 switch (gfc_next_char ())
263 rname
= "hexadecimal";
269 /* No whitespace allowed here. */
271 delim
= gfc_next_char ();
272 if (delim
!= '\'' && delim
!= '\"')
275 old_loc
= gfc_current_locus
;
277 length
= match_digits (0, radix
, NULL
);
280 gfc_error ("Empty set of digits in %s constants at %C", rname
);
284 if (gfc_next_char () != delim
)
286 gfc_error ("Illegal character in %s constant at %C.", rname
);
290 gfc_current_locus
= old_loc
;
292 buffer
= alloca (length
+ 1);
293 memset (buffer
, '\0', length
+ 1);
295 match_digits (0, radix
, buffer
);
298 e
= gfc_convert_integer (buffer
, gfc_default_integer_kind
, radix
,
301 if (gfc_range_check (e
) != ARITH_OK
)
303 gfc_error ("Integer too big for default integer kind at %C");
311 && (gfc_notify_std (GFC_STD_GNU
, "Extension: Hexadecimal "
312 "constant at %C uses non-standard syntax.")
323 gfc_current_locus
= old_loc
;
328 /* Match a real constant of some sort. */
331 match_real_constant (gfc_expr
** result
, int signflag
)
333 int kind
, c
, count
, seen_dp
, seen_digits
, exp_char
;
334 locus old_loc
, temp_loc
;
338 old_loc
= gfc_current_locus
;
339 gfc_gobble_whitespace ();
348 c
= gfc_next_char ();
349 if (signflag
&& (c
== '+' || c
== '-'))
351 c
= gfc_next_char ();
355 /* Scan significand. */
356 for (;; c
= gfc_next_char (), count
++)
363 /* Check to see if "." goes with a following operator like ".eq.". */
364 temp_loc
= gfc_current_locus
;
365 c
= gfc_next_char ();
367 if (c
== 'e' || c
== 'd' || c
== 'q')
369 c
= gfc_next_char ();
371 goto done
; /* Operator named .e. or .d. */
375 goto done
; /* Distinguish 1.e9 from 1.eq.2 */
377 gfc_current_locus
= temp_loc
;
391 if (!seen_digits
|| (c
!= 'e' && c
!= 'd' && c
!= 'q'))
396 c
= gfc_next_char ();
399 if (c
== '+' || c
== '-')
400 { /* optional sign */
401 c
= gfc_next_char ();
407 /* TODO: seen_digits is always true at this point */
410 gfc_current_locus
= old_loc
;
411 return MATCH_NO
; /* ".e" can be something else */
414 gfc_error ("Missing exponent in real number at %C");
420 c
= gfc_next_char ();
425 /* See what we've got! */
426 if (!seen_digits
|| (!seen_dp
&& exp_char
== ' '))
428 gfc_current_locus
= old_loc
;
432 /* Convert the number. */
433 gfc_current_locus
= old_loc
;
434 gfc_gobble_whitespace ();
436 buffer
= alloca (count
+ 1);
437 memset (buffer
, '\0', count
+ 1);
439 /* Hack for mpfr_set_str(). */
443 *p
= gfc_next_char ();
444 if (*p
== 'd' || *p
== 'q')
460 ("Real number at %C has a 'd' exponent and an explicit kind");
463 kind
= gfc_default_double_kind
;
470 ("Real number at %C has a 'q' exponent and an explicit kind");
473 kind
= gfc_option
.q_kind
;
478 kind
= gfc_default_real_kind
;
480 if (gfc_validate_kind (BT_REAL
, kind
, true) < 0)
482 gfc_error ("Invalid real kind %d at %C", kind
);
487 e
= gfc_convert_real (buffer
, kind
, &gfc_current_locus
);
489 switch (gfc_range_check (e
))
494 gfc_error ("Real constant overflows its kind at %C");
497 case ARITH_UNDERFLOW
:
498 if (gfc_option
.warn_underflow
)
499 gfc_warning ("Real constant underflows its kind at %C");
500 mpfr_set_ui (e
->value
.real
, 0, GFC_RND_MODE
);
504 gfc_internal_error ("gfc_range_check() returned bad value");
516 /* Match a substring reference. */
519 match_substring (gfc_charlen
* cl
, int init
, gfc_ref
** result
)
521 gfc_expr
*start
, *end
;
529 old_loc
= gfc_current_locus
;
531 m
= gfc_match_char ('(');
535 if (gfc_match_char (':') != MATCH_YES
)
538 m
= gfc_match_init_expr (&start
);
540 m
= gfc_match_expr (&start
);
548 m
= gfc_match_char (':');
553 if (gfc_match_char (')') != MATCH_YES
)
556 m
= gfc_match_init_expr (&end
);
558 m
= gfc_match_expr (&end
);
562 if (m
== MATCH_ERROR
)
565 m
= gfc_match_char (')');
570 /* Optimize away the (:) reference. */
571 if (start
== NULL
&& end
== NULL
)
575 ref
= gfc_get_ref ();
577 ref
->type
= REF_SUBSTRING
;
579 start
= gfc_int_expr (1);
580 ref
->u
.ss
.start
= start
;
581 if (end
== NULL
&& cl
)
582 end
= gfc_copy_expr (cl
->length
);
584 ref
->u
.ss
.length
= cl
;
591 gfc_error ("Syntax error in SUBSTRING specification at %C");
595 gfc_free_expr (start
);
598 gfc_current_locus
= old_loc
;
603 /* Reads the next character of a string constant, taking care to
604 return doubled delimiters on the input as a single instance of
607 Special return values are:
608 -1 End of the string, as determined by the delimiter
609 -2 Unterminated string detected
611 Backslash codes are also expanded at this time. */
614 next_string_char (char delimiter
)
619 c
= gfc_next_char_literal (1);
626 old_locus
= gfc_current_locus
;
628 switch (gfc_next_char_literal (1))
656 /* Unknown backslash codes are simply not expanded */
657 gfc_current_locus
= old_locus
;
665 old_locus
= gfc_current_locus
;
666 c
= gfc_next_char_literal (1);
670 gfc_current_locus
= old_locus
;
676 /* Special case of gfc_match_name() that matches a parameter kind name
677 before a string constant. This takes case of the weird but legal
678 case of: weird case of:
682 where kind____ is a parameter. gfc_match_name() will happily slurp
683 up all the underscores, which leads to problems. If we return
684 MATCH_YES, the parse pointer points to the final underscore, which
685 is not part of the name. We never return MATCH_ERROR-- errors in
686 the name will be detected later. */
689 match_charkind_name (char *name
)
695 gfc_gobble_whitespace ();
696 c
= gfc_next_char ();
705 old_loc
= gfc_current_locus
;
706 c
= gfc_next_char ();
710 peek
= gfc_peek_char ();
712 if (peek
== '\'' || peek
== '\"')
714 gfc_current_locus
= old_loc
;
722 && (gfc_option
.flag_dollar_ok
&& c
!= '$'))
726 if (++len
> GFC_MAX_SYMBOL_LEN
)
734 /* See if the current input matches a character constant. Lots of
735 contortions have to be done to match the kind parameter which comes
736 before the actual string. The main consideration is that we don't
737 want to error out too quickly. For example, we don't actually do
738 any validation of the kinds until we have actually seen a legal
739 delimiter. Using match_kind_param() generates errors too quickly. */
742 match_string_constant (gfc_expr
** result
)
744 char *p
, name
[GFC_MAX_SYMBOL_LEN
+ 1];
745 int i
, c
, kind
, length
, delimiter
;
746 locus old_locus
, start_locus
;
752 old_locus
= gfc_current_locus
;
754 gfc_gobble_whitespace ();
756 start_locus
= gfc_current_locus
;
758 c
= gfc_next_char ();
759 if (c
== '\'' || c
== '"')
761 kind
= gfc_default_character_kind
;
771 kind
= kind
* 10 + c
- '0';
774 c
= gfc_next_char ();
780 gfc_current_locus
= old_locus
;
782 m
= match_charkind_name (name
);
786 if (gfc_find_symbol (name
, NULL
, 1, &sym
)
788 || sym
->attr
.flavor
!= FL_PARAMETER
)
792 c
= gfc_next_char ();
797 gfc_gobble_whitespace ();
798 c
= gfc_next_char ();
804 gfc_gobble_whitespace ();
805 start_locus
= gfc_current_locus
;
807 c
= gfc_next_char ();
808 if (c
!= '\'' && c
!= '"')
813 q
= gfc_extract_int (sym
->value
, &kind
);
821 if (gfc_validate_kind (BT_CHARACTER
, kind
, true) < 0)
823 gfc_error ("Invalid kind %d for CHARACTER constant at %C", kind
);
828 /* Scan the string into a block of memory by first figuring out how
829 long it is, allocating the structure, then re-reading it. This
830 isn't particularly efficient, but string constants aren't that
831 common in most code. TODO: Use obstacks? */
838 c
= next_string_char (delimiter
);
843 gfc_current_locus
= start_locus
;
844 gfc_error ("Unterminated character constant beginning at %C");
853 e
->expr_type
= EXPR_CONSTANT
;
855 e
->ts
.type
= BT_CHARACTER
;
857 e
->where
= start_locus
;
859 e
->value
.character
.string
= p
= gfc_getmem (length
+ 1);
860 e
->value
.character
.length
= length
;
862 gfc_current_locus
= start_locus
;
863 gfc_next_char (); /* Skip delimiter */
865 for (i
= 0; i
< length
; i
++)
866 *p
++ = next_string_char (delimiter
);
868 *p
= '\0'; /* TODO: C-style string is for development/debug purposes. */
870 if (next_string_char (delimiter
) != -1)
871 gfc_internal_error ("match_string_constant(): Delimiter not found");
873 if (match_substring (NULL
, 0, &e
->ref
) != MATCH_NO
)
874 e
->expr_type
= EXPR_SUBSTRING
;
881 gfc_current_locus
= old_locus
;
886 /* Match a .true. or .false. */
889 match_logical_constant (gfc_expr
** result
)
891 static mstring logical_ops
[] = {
892 minit (".false.", 0),
900 i
= gfc_match_strings (logical_ops
);
908 kind
= gfc_default_logical_kind
;
910 if (gfc_validate_kind (BT_LOGICAL
, kind
, true) < 0)
911 gfc_error ("Bad kind for logical constant at %C");
915 e
->expr_type
= EXPR_CONSTANT
;
916 e
->value
.logical
= i
;
917 e
->ts
.type
= BT_LOGICAL
;
919 e
->where
= gfc_current_locus
;
926 /* Match a real or imaginary part of a complex constant that is a
927 symbolic constant. */
930 match_sym_complex_part (gfc_expr
** result
)
932 char name
[GFC_MAX_SYMBOL_LEN
+ 1];
937 m
= gfc_match_name (name
);
941 if (gfc_find_symbol (name
, NULL
, 1, &sym
) || sym
== NULL
)
944 if (sym
->attr
.flavor
!= FL_PARAMETER
)
946 gfc_error ("Expected PARAMETER symbol in complex constant at %C");
950 if (!gfc_numeric_ts (&sym
->value
->ts
))
952 gfc_error ("Numeric PARAMETER required in complex constant at %C");
956 if (sym
->value
->rank
!= 0)
958 gfc_error ("Scalar PARAMETER required in complex constant at %C");
962 switch (sym
->value
->ts
.type
)
965 e
= gfc_copy_expr (sym
->value
);
969 e
= gfc_complex2real (sym
->value
, sym
->value
->ts
.kind
);
975 e
= gfc_int2real (sym
->value
, gfc_default_real_kind
);
981 gfc_internal_error ("gfc_match_sym_complex_part(): Bad type");
984 *result
= e
; /* e is a scalar, real, constant expression */
988 gfc_error ("Error converting PARAMETER constant in complex constant at %C");
993 /* Match the real and imaginary parts of a complex number. This
994 subroutine is essentially match_real_constant() modified in a
995 couple of ways: A sign is always allowed and numbers that would
996 look like an integer to match_real_constant() are automatically
997 created as floating point numbers. The messiness involved with
998 making sure a decimal point belongs to the number and not a
999 trailing operator is not necessary here either (Hooray!). */
1002 match_const_complex_part (gfc_expr
** result
)
1004 int kind
, seen_digits
, seen_dp
, count
;
1005 char *p
, c
, exp_char
, *buffer
;
1008 old_loc
= gfc_current_locus
;
1009 gfc_gobble_whitespace ();
1016 c
= gfc_next_char ();
1017 if (c
== '-' || c
== '+')
1019 c
= gfc_next_char ();
1023 for (;; c
= gfc_next_char (), count
++)
1042 if (!seen_digits
|| (c
!= 'd' && c
!= 'e'))
1046 /* Scan exponent. */
1047 c
= gfc_next_char ();
1050 if (c
== '+' || c
== '-')
1051 { /* optional sign */
1052 c
= gfc_next_char ();
1058 gfc_error ("Missing exponent in real number at %C");
1064 c
= gfc_next_char ();
1072 /* Convert the number. */
1073 gfc_current_locus
= old_loc
;
1074 gfc_gobble_whitespace ();
1076 buffer
= alloca (count
+ 1);
1077 memset (buffer
, '\0', count
+ 1);
1079 /* Hack for mpfr_set_str(). */
1083 c
= gfc_next_char ();
1084 if (c
== 'd' || c
== 'q')
1096 /* If the number looked like an integer, forget about a kind we may
1097 have seen, otherwise validate the kind against real kinds. */
1098 if (seen_dp
== 0 && exp_char
== ' ')
1101 kind
= gfc_default_integer_kind
;
1106 if (exp_char
== 'd')
1111 ("Real number at %C has a 'd' exponent and an explicit kind");
1114 kind
= gfc_default_double_kind
;
1120 kind
= gfc_default_real_kind
;
1123 if (gfc_validate_kind (BT_REAL
, kind
, true) < 0)
1125 gfc_error ("Invalid real kind %d at %C", kind
);
1130 *result
= gfc_convert_real (buffer
, kind
, &gfc_current_locus
);
1134 gfc_current_locus
= old_loc
;
1139 /* Match a real or imaginary part of a complex number. */
1142 match_complex_part (gfc_expr
** result
)
1146 m
= match_sym_complex_part (result
);
1150 return match_const_complex_part (result
);
1154 /* Try to match a complex constant. */
1157 match_complex_constant (gfc_expr
** result
)
1159 gfc_expr
*e
, *real
, *imag
;
1160 gfc_error_buf old_error
;
1161 gfc_typespec target
;
1166 old_loc
= gfc_current_locus
;
1167 real
= imag
= e
= NULL
;
1169 m
= gfc_match_char ('(');
1173 gfc_push_error (&old_error
);
1175 m
= match_complex_part (&real
);
1179 if (gfc_match_char (',') == MATCH_NO
)
1181 gfc_pop_error (&old_error
);
1186 /* If m is error, then something was wrong with the real part and we
1187 assume we have a complex constant because we've seen the ','. An
1188 ambiguous case here is the start of an iterator list of some
1189 sort. These sort of lists are matched prior to coming here. */
1191 if (m
== MATCH_ERROR
)
1193 gfc_pop_error (&old_error
);
1195 m
= match_complex_part (&imag
);
1198 if (m
== MATCH_ERROR
)
1201 m
= gfc_match_char (')');
1205 if (m
== MATCH_ERROR
)
1208 /* Decide on the kind of this complex number. */
1209 kind
= gfc_kind_max (real
, imag
);
1210 target
.type
= BT_REAL
;
1213 if (kind
!= real
->ts
.kind
)
1214 gfc_convert_type (real
, &target
, 2);
1215 if (kind
!= imag
->ts
.kind
)
1216 gfc_convert_type (imag
, &target
, 2);
1218 e
= gfc_convert_complex (real
, imag
, kind
);
1219 e
->where
= gfc_current_locus
;
1221 gfc_free_expr (real
);
1222 gfc_free_expr (imag
);
1228 gfc_error ("Syntax error in COMPLEX constant at %C");
1233 gfc_free_expr (real
);
1234 gfc_free_expr (imag
);
1235 gfc_current_locus
= old_loc
;
1241 /* Match constants in any of several forms. Returns nonzero for a
1242 match, zero for no match. */
1245 gfc_match_literal_constant (gfc_expr
** result
, int signflag
)
1249 m
= match_complex_constant (result
);
1253 m
= match_string_constant (result
);
1257 m
= match_boz_constant (result
);
1261 m
= match_real_constant (result
, signflag
);
1265 m
= match_integer_constant (result
, signflag
);
1269 m
= match_logical_constant (result
);
1277 /* Match a single actual argument value. An actual argument is
1278 usually an expression, but can also be a procedure name. If the
1279 argument is a single name, it is not always possible to tell
1280 whether the name is a dummy procedure or not. We treat these cases
1281 by creating an argument that looks like a dummy procedure and
1282 fixing things later during resolution. */
1285 match_actual_arg (gfc_expr
** result
)
1287 char name
[GFC_MAX_SYMBOL_LEN
+ 1];
1288 gfc_symtree
*symtree
;
1293 where
= gfc_current_locus
;
1295 switch (gfc_match_name (name
))
1304 w
= gfc_current_locus
;
1305 gfc_gobble_whitespace ();
1306 c
= gfc_next_char ();
1307 gfc_current_locus
= w
;
1309 if (c
!= ',' && c
!= ')')
1312 if (gfc_find_sym_tree (name
, NULL
, 1, &symtree
))
1314 /* Handle error elsewhere. */
1316 /* Eliminate a couple of common cases where we know we don't
1317 have a function argument. */
1318 if (symtree
== NULL
)
1320 gfc_get_sym_tree (name
, NULL
, &symtree
);
1321 gfc_set_sym_referenced (symtree
->n
.sym
);
1327 sym
= symtree
->n
.sym
;
1328 gfc_set_sym_referenced (sym
);
1329 if (sym
->attr
.flavor
!= FL_PROCEDURE
1330 && sym
->attr
.flavor
!= FL_UNKNOWN
)
1333 /* If the symbol is a function with itself as the result and
1334 is being defined, then we have a variable. */
1335 if (sym
->result
== sym
1336 && (gfc_current_ns
->proc_name
== sym
1337 || (gfc_current_ns
->parent
!= NULL
1338 && gfc_current_ns
->parent
->proc_name
== sym
)))
1342 e
= gfc_get_expr (); /* Leave it unknown for now */
1343 e
->symtree
= symtree
;
1344 e
->expr_type
= EXPR_VARIABLE
;
1345 e
->ts
.type
= BT_PROCEDURE
;
1352 gfc_current_locus
= where
;
1353 return gfc_match_expr (result
);
1357 /* Match a keyword argument. */
1360 match_keyword_arg (gfc_actual_arglist
* actual
, gfc_actual_arglist
* base
)
1362 char name
[GFC_MAX_SYMBOL_LEN
+ 1];
1363 gfc_actual_arglist
*a
;
1367 name_locus
= gfc_current_locus
;
1368 m
= gfc_match_name (name
);
1372 if (gfc_match_char ('=') != MATCH_YES
)
1378 m
= match_actual_arg (&actual
->expr
);
1382 /* Make sure this name has not appeared yet. */
1384 if (name
[0] != '\0')
1386 for (a
= base
; a
; a
= a
->next
)
1387 if (strcmp (a
->name
, name
) == 0)
1390 ("Keyword '%s' at %C has already appeared in the current "
1391 "argument list", name
);
1396 strcpy (actual
->name
, name
);
1400 gfc_current_locus
= name_locus
;
1405 /* Matches an actual argument list of a function or subroutine, from
1406 the opening parenthesis to the closing parenthesis. The argument
1407 list is assumed to allow keyword arguments because we don't know if
1408 the symbol associated with the procedure has an implicit interface
1409 or not. We make sure keywords are unique. If SUB_FLAG is set,
1410 we're matching the argument list of a subroutine. */
1413 gfc_match_actual_arglist (int sub_flag
, gfc_actual_arglist
** argp
)
1415 gfc_actual_arglist
*head
, *tail
;
1417 gfc_st_label
*label
;
1421 *argp
= tail
= NULL
;
1422 old_loc
= gfc_current_locus
;
1426 if (gfc_match_char ('(') == MATCH_NO
)
1427 return (sub_flag
) ? MATCH_YES
: MATCH_NO
;
1429 if (gfc_match_char (')') == MATCH_YES
)
1436 head
= tail
= gfc_get_actual_arglist ();
1439 tail
->next
= gfc_get_actual_arglist ();
1443 if (sub_flag
&& gfc_match_char ('*') == MATCH_YES
)
1445 m
= gfc_match_st_label (&label
, 0);
1447 gfc_error ("Expected alternate return label at %C");
1451 tail
->label
= label
;
1455 /* After the first keyword argument is seen, the following
1456 arguments must also have keywords. */
1459 m
= match_keyword_arg (tail
, head
);
1461 if (m
== MATCH_ERROR
)
1466 ("Missing keyword name in actual argument list at %C");
1473 /* See if we have the first keyword argument. */
1474 m
= match_keyword_arg (tail
, head
);
1477 if (m
== MATCH_ERROR
)
1482 /* Try for a non-keyword argument. */
1483 m
= match_actual_arg (&tail
->expr
);
1484 if (m
== MATCH_ERROR
)
1492 if (gfc_match_char (')') == MATCH_YES
)
1494 if (gfc_match_char (',') != MATCH_YES
)
1502 gfc_error ("Syntax error in argument list at %C");
1505 gfc_free_actual_arglist (head
);
1506 gfc_current_locus
= old_loc
;
1512 /* Used by match_varspec() to extend the reference list by one
1516 extend_ref (gfc_expr
* primary
, gfc_ref
* tail
)
1519 if (primary
->ref
== NULL
)
1520 primary
->ref
= tail
= gfc_get_ref ();
1524 gfc_internal_error ("extend_ref(): Bad tail");
1525 tail
->next
= gfc_get_ref ();
1533 /* Match any additional specifications associated with the current
1534 variable like member references or substrings. If equiv_flag is
1535 set we only match stuff that is allowed inside an EQUIVALENCE
1539 match_varspec (gfc_expr
* primary
, int equiv_flag
)
1541 char name
[GFC_MAX_SYMBOL_LEN
+ 1];
1542 gfc_ref
*substring
, *tail
;
1543 gfc_component
*component
;
1549 if (primary
->symtree
->n
.sym
->attr
.dimension
1551 && gfc_peek_char () == '('))
1554 tail
= extend_ref (primary
, tail
);
1555 tail
->type
= REF_ARRAY
;
1557 m
= gfc_match_array_ref (&tail
->u
.ar
, primary
->symtree
->n
.sym
->as
,
1563 sym
= primary
->symtree
->n
.sym
;
1564 primary
->ts
= sym
->ts
;
1566 if (sym
->ts
.type
!= BT_DERIVED
|| gfc_match_char ('%') != MATCH_YES
)
1567 goto check_substring
;
1569 sym
= sym
->ts
.derived
;
1573 m
= gfc_match_name (name
);
1575 gfc_error ("Expected structure component name at %C");
1579 component
= gfc_find_component (sym
, name
);
1580 if (component
== NULL
)
1583 tail
= extend_ref (primary
, tail
);
1584 tail
->type
= REF_COMPONENT
;
1586 tail
->u
.c
.component
= component
;
1587 tail
->u
.c
.sym
= sym
;
1589 primary
->ts
= component
->ts
;
1591 if (component
->as
!= NULL
)
1593 tail
= extend_ref (primary
, tail
);
1594 tail
->type
= REF_ARRAY
;
1596 m
= gfc_match_array_ref (&tail
->u
.ar
, component
->as
, equiv_flag
);
1601 if (component
->ts
.type
!= BT_DERIVED
1602 || gfc_match_char ('%') != MATCH_YES
)
1605 sym
= component
->ts
.derived
;
1609 if (primary
->ts
.type
== BT_CHARACTER
)
1611 switch (match_substring (primary
->ts
.cl
, equiv_flag
, &substring
))
1615 primary
->ref
= substring
;
1617 tail
->next
= substring
;
1619 if (primary
->expr_type
== EXPR_CONSTANT
)
1620 primary
->expr_type
= EXPR_SUBSTRING
;
1636 /* Given an expression that is a variable, figure out what the
1637 ultimate variable's type and attribute is, traversing the reference
1638 structures if necessary.
1640 This subroutine is trickier than it looks. We start at the base
1641 symbol and store the attribute. Component references load a
1642 completely new attribute.
1644 A couple of rules come into play. Subobjects of targets are always
1645 targets themselves. If we see a component that goes through a
1646 pointer, then the expression must also be a target, since the
1647 pointer is associated with something (if it isn't core will soon be
1648 dumped). If we see a full part or section of an array, the
1649 expression is also an array.
1651 We can have at most one full array reference. */
1654 gfc_variable_attr (gfc_expr
* expr
, gfc_typespec
* ts
)
1656 int dimension
, pointer
, target
;
1657 symbol_attribute attr
;
1660 if (expr
->expr_type
!= EXPR_VARIABLE
)
1661 gfc_internal_error ("gfc_variable_attr(): Expression isn't a variable");
1664 attr
= expr
->symtree
->n
.sym
->attr
;
1666 dimension
= attr
.dimension
;
1667 pointer
= attr
.pointer
;
1669 target
= attr
.target
;
1673 if (ts
!= NULL
&& expr
->ts
.type
== BT_UNKNOWN
)
1674 *ts
= expr
->symtree
->n
.sym
->ts
;
1676 for (; ref
; ref
= ref
->next
)
1681 switch (ref
->u
.ar
.type
)
1697 gfc_internal_error ("gfc_variable_attr(): Bad array reference");
1703 gfc_get_component_attr (&attr
, ref
->u
.c
.component
);
1705 *ts
= ref
->u
.c
.component
->ts
;
1707 pointer
= ref
->u
.c
.component
->pointer
;
1718 attr
.dimension
= dimension
;
1719 attr
.pointer
= pointer
;
1720 attr
.target
= target
;
1726 /* Return the attribute from a general expression. */
1729 gfc_expr_attr (gfc_expr
* e
)
1731 symbol_attribute attr
;
1733 switch (e
->expr_type
)
1736 attr
= gfc_variable_attr (e
, NULL
);
1740 gfc_clear_attr (&attr
);
1742 if (e
->value
.function
.esym
!= NULL
)
1743 attr
= e
->value
.function
.esym
->result
->attr
;
1745 /* TODO: NULL() returns pointers. May have to take care of this
1751 gfc_clear_attr (&attr
);
1759 /* Match a structure constructor. The initial symbol has already been
1763 gfc_match_structure_constructor (gfc_symbol
* sym
, gfc_expr
** result
)
1765 gfc_constructor
*head
, *tail
;
1766 gfc_component
*comp
;
1773 if (gfc_match_char ('(') != MATCH_YES
)
1776 where
= gfc_current_locus
;
1778 gfc_find_component (sym
, NULL
);
1780 for (comp
= sym
->components
; comp
; comp
= comp
->next
)
1783 tail
= head
= gfc_get_constructor ();
1786 tail
->next
= gfc_get_constructor ();
1790 m
= gfc_match_expr (&tail
->expr
);
1793 if (m
== MATCH_ERROR
)
1796 if (gfc_match_char (',') == MATCH_YES
)
1798 if (comp
->next
== NULL
)
1801 ("Too many components in structure constructor at %C");
1811 if (gfc_match_char (')') != MATCH_YES
)
1814 if (comp
->next
!= NULL
)
1816 gfc_error ("Too few components in structure constructor at %C");
1820 e
= gfc_get_expr ();
1822 e
->expr_type
= EXPR_STRUCTURE
;
1824 e
->ts
.type
= BT_DERIVED
;
1825 e
->ts
.derived
= sym
;
1828 e
->value
.constructor
= head
;
1834 gfc_error ("Syntax error in structure constructor at %C");
1837 gfc_free_constructor (head
);
1842 /* Matches a variable name followed by anything that might follow it--
1843 array reference, argument list of a function, etc. */
1846 gfc_match_rvalue (gfc_expr
** result
)
1848 gfc_actual_arglist
*actual_arglist
;
1849 char name
[GFC_MAX_SYMBOL_LEN
+ 1], argname
[GFC_MAX_SYMBOL_LEN
+ 1];
1852 gfc_symtree
*symtree
;
1853 locus where
, old_loc
;
1858 m
= gfc_match_name (name
);
1862 if (gfc_find_state (COMP_INTERFACE
) == SUCCESS
)
1863 i
= gfc_get_sym_tree (name
, NULL
, &symtree
);
1865 i
= gfc_get_ha_sym_tree (name
, &symtree
);
1870 sym
= symtree
->n
.sym
;
1872 where
= gfc_current_locus
;
1874 gfc_set_sym_referenced (sym
);
1876 if (sym
->attr
.function
&& sym
->result
== sym
1877 && (gfc_current_ns
->proc_name
== sym
1878 || (gfc_current_ns
->parent
!= NULL
1879 && gfc_current_ns
->parent
->proc_name
== sym
)))
1882 if (sym
->attr
.function
|| sym
->attr
.external
|| sym
->attr
.intrinsic
)
1885 if (sym
->attr
.generic
)
1886 goto generic_function
;
1888 switch (sym
->attr
.flavor
)
1892 if (sym
->ts
.type
== BT_UNKNOWN
&& gfc_peek_char () == '%'
1893 && gfc_get_default_type (sym
, sym
->ns
)->type
== BT_DERIVED
)
1894 gfc_set_default_type (sym
, 0, sym
->ns
);
1896 e
= gfc_get_expr ();
1898 e
->expr_type
= EXPR_VARIABLE
;
1899 e
->symtree
= symtree
;
1901 m
= match_varspec (e
, 0);
1906 && sym
->value
->expr_type
!= EXPR_ARRAY
)
1907 e
= gfc_copy_expr (sym
->value
);
1910 e
= gfc_get_expr ();
1911 e
->expr_type
= EXPR_VARIABLE
;
1914 e
->symtree
= symtree
;
1915 m
= match_varspec (e
, 0);
1919 sym
= gfc_use_derived (sym
);
1923 m
= gfc_match_structure_constructor (sym
, &e
);
1926 /* If we're here, then the name is known to be the name of a
1927 procedure, yet it is not sure to be the name of a function. */
1929 if (sym
->attr
.subroutine
)
1931 gfc_error ("Unexpected use of subroutine name '%s' at %C",
1937 /* At this point, the name has to be a non-statement function.
1938 If the name is the same as the current function being
1939 compiled, then we have a variable reference (to the function
1940 result) if the name is non-recursive. */
1942 st
= gfc_enclosing_unit (NULL
);
1944 if (st
!= NULL
&& st
->state
== COMP_FUNCTION
1946 && !sym
->attr
.recursive
)
1948 e
= gfc_get_expr ();
1949 e
->symtree
= symtree
;
1950 e
->expr_type
= EXPR_VARIABLE
;
1952 m
= match_varspec (e
, 0);
1956 /* Match a function reference. */
1958 m
= gfc_match_actual_arglist (0, &actual_arglist
);
1961 if (sym
->attr
.proc
== PROC_ST_FUNCTION
)
1962 gfc_error ("Statement function '%s' requires argument list at %C",
1965 gfc_error ("Function '%s' requires an argument list at %C",
1978 gfc_get_ha_sym_tree (name
, &symtree
); /* Can't fail */
1979 sym
= symtree
->n
.sym
;
1981 e
= gfc_get_expr ();
1982 e
->symtree
= symtree
;
1983 e
->expr_type
= EXPR_FUNCTION
;
1984 e
->value
.function
.actual
= actual_arglist
;
1985 e
->where
= gfc_current_locus
;
1987 if (sym
->as
!= NULL
)
1988 e
->rank
= sym
->as
->rank
;
1990 if (!sym
->attr
.function
1991 && gfc_add_function (&sym
->attr
, NULL
) == FAILURE
)
1997 if (sym
->result
== NULL
)
2005 /* Special case for derived type variables that get their types
2006 via an IMPLICIT statement. This can't wait for the
2007 resolution phase. */
2009 if (gfc_peek_char () == '%'
2010 && gfc_get_default_type (sym
, sym
->ns
)->type
== BT_DERIVED
)
2011 gfc_set_default_type (sym
, 0, sym
->ns
);
2013 /* If the symbol has a dimension attribute, the expression is a
2016 if (sym
->attr
.dimension
)
2018 if (gfc_add_flavor (&sym
->attr
, FL_VARIABLE
, NULL
) == FAILURE
)
2024 e
= gfc_get_expr ();
2025 e
->symtree
= symtree
;
2026 e
->expr_type
= EXPR_VARIABLE
;
2027 m
= match_varspec (e
, 0);
2031 /* Name is not an array, so we peek to see if a '(' implies a
2032 function call or a substring reference. Otherwise the
2033 variable is just a scalar. */
2035 gfc_gobble_whitespace ();
2036 if (gfc_peek_char () != '(')
2038 /* Assume a scalar variable */
2039 e
= gfc_get_expr ();
2040 e
->symtree
= symtree
;
2041 e
->expr_type
= EXPR_VARIABLE
;
2043 if (gfc_add_flavor (&sym
->attr
, FL_VARIABLE
, NULL
) == FAILURE
)
2050 m
= match_varspec (e
, 0);
2054 /* See if this is a function reference with a keyword argument
2055 as first argument. We do this because otherwise a spurious
2056 symbol would end up in the symbol table. */
2058 old_loc
= gfc_current_locus
;
2059 m2
= gfc_match (" ( %n =", argname
);
2060 gfc_current_locus
= old_loc
;
2062 e
= gfc_get_expr ();
2063 e
->symtree
= symtree
;
2065 if (m2
!= MATCH_YES
)
2067 /* See if this could possibly be a substring reference of a name
2068 that we're not sure is a variable yet. */
2070 if ((sym
->ts
.type
== BT_UNKNOWN
|| sym
->ts
.type
== BT_CHARACTER
)
2071 && match_substring (sym
->ts
.cl
, 0, &e
->ref
) == MATCH_YES
)
2074 e
->expr_type
= EXPR_VARIABLE
;
2076 if (sym
->attr
.flavor
!= FL_VARIABLE
2077 && gfc_add_flavor (&sym
->attr
, FL_VARIABLE
, NULL
) == FAILURE
)
2083 if (sym
->ts
.type
== BT_UNKNOWN
2084 && gfc_set_default_type (sym
, 1, NULL
) == FAILURE
)
2096 /* Give up, assume we have a function. */
2098 gfc_get_sym_tree (name
, NULL
, &symtree
); /* Can't fail */
2099 sym
= symtree
->n
.sym
;
2100 e
->expr_type
= EXPR_FUNCTION
;
2102 if (!sym
->attr
.function
2103 && gfc_add_function (&sym
->attr
, NULL
) == FAILURE
)
2111 m
= gfc_match_actual_arglist (0, &e
->value
.function
.actual
);
2113 gfc_error ("Missing argument list in function '%s' at %C", sym
->name
);
2121 /* If our new function returns a character, array or structure
2122 type, it might have subsequent references. */
2124 m
= match_varspec (e
, 0);
2131 gfc_get_sym_tree (name
, NULL
, &symtree
); /* Can't fail */
2133 e
= gfc_get_expr ();
2134 e
->symtree
= symtree
;
2135 e
->expr_type
= EXPR_FUNCTION
;
2137 m
= gfc_match_actual_arglist (0, &e
->value
.function
.actual
);
2141 gfc_error ("Symbol at %C is not appropriate for an expression");
2157 /* Match a variable, ie something that can be assigned to. This
2158 starts as a symbol, can be a structure component or an array
2159 reference. It can be a function if the function doesn't have a
2160 separate RESULT variable. If the symbol has not been previously
2161 seen, we assume it is a variable. */
2164 gfc_match_variable (gfc_expr
** result
, int equiv_flag
)
2172 m
= gfc_match_sym_tree (&st
, 1);
2175 where
= gfc_current_locus
;
2178 gfc_set_sym_referenced (sym
);
2179 switch (sym
->attr
.flavor
)
2185 if (gfc_add_flavor (&sym
->attr
, FL_VARIABLE
, NULL
) == FAILURE
)
2188 /* Special case for derived type variables that get their types
2189 via an IMPLICIT statement. This can't wait for the
2190 resolution phase. */
2192 if (gfc_peek_char () == '%'
2193 && gfc_get_default_type (sym
, sym
->ns
)->type
== BT_DERIVED
)
2194 gfc_set_default_type (sym
, 0, sym
->ns
);
2199 /* Check for a nonrecursive function result */
2200 if (sym
->attr
.function
&& (sym
->result
== sym
|| sym
->attr
.entry
))
2203 /* If a function result is a derived type, then the derived
2204 type may still have to be resolved. */
2206 if (sym
->ts
.type
== BT_DERIVED
2207 && gfc_use_derived (sym
->ts
.derived
) == NULL
)
2213 /* Fall through to error */
2216 gfc_error ("Expected VARIABLE at %C");
2220 expr
= gfc_get_expr ();
2222 expr
->expr_type
= EXPR_VARIABLE
;
2225 expr
->where
= where
;
2227 /* Now see if we have to do more. */
2228 m
= match_varspec (expr
, equiv_flag
);
2231 gfc_free_expr (expr
);