1 /* Deal with I/O statements & related stuff.
2 Copyright (C) 2000-2015 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 3, 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 COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
30 format_asterisk
= {0, NULL
, NULL
, -1, ST_LABEL_FORMAT
, ST_LABEL_FORMAT
, NULL
,
35 const char *name
, *spec
, *value
;
41 tag_file
= {"FILE", " file =", " %e", BT_CHARACTER
},
42 tag_status
= {"STATUS", " status =", " %e", BT_CHARACTER
},
43 tag_e_access
= {"ACCESS", " access =", " %e", BT_CHARACTER
},
44 tag_e_form
= {"FORM", " form =", " %e", BT_CHARACTER
},
45 tag_e_recl
= {"RECL", " recl =", " %e", BT_INTEGER
},
46 tag_e_blank
= {"BLANK", " blank =", " %e", BT_CHARACTER
},
47 tag_e_position
= {"POSITION", " position =", " %e", BT_CHARACTER
},
48 tag_e_action
= {"ACTION", " action =", " %e", BT_CHARACTER
},
49 tag_e_delim
= {"DELIM", " delim =", " %e", BT_CHARACTER
},
50 tag_e_pad
= {"PAD", " pad =", " %e", BT_CHARACTER
},
51 tag_e_decimal
= {"DECIMAL", " decimal =", " %e", BT_CHARACTER
},
52 tag_e_encoding
= {"ENCODING", " encoding =", " %e", BT_CHARACTER
},
53 tag_e_async
= {"ASYNCHRONOUS", " asynchronous =", " %e", BT_CHARACTER
},
54 tag_e_round
= {"ROUND", " round =", " %e", BT_CHARACTER
},
55 tag_e_sign
= {"SIGN", " sign =", " %e", BT_CHARACTER
},
56 tag_unit
= {"UNIT", " unit =", " %e", BT_INTEGER
},
57 tag_advance
= {"ADVANCE", " advance =", " %e", BT_CHARACTER
},
58 tag_rec
= {"REC", " rec =", " %e", BT_INTEGER
},
59 tag_spos
= {"POSITION", " pos =", " %e", BT_INTEGER
},
60 tag_format
= {"FORMAT", NULL
, NULL
, BT_CHARACTER
},
61 tag_iomsg
= {"IOMSG", " iomsg =", " %e", BT_CHARACTER
},
62 tag_iostat
= {"IOSTAT", " iostat =", " %v", BT_INTEGER
},
63 tag_size
= {"SIZE", " size =", " %v", BT_INTEGER
},
64 tag_exist
= {"EXIST", " exist =", " %v", BT_LOGICAL
},
65 tag_opened
= {"OPENED", " opened =", " %v", BT_LOGICAL
},
66 tag_named
= {"NAMED", " named =", " %v", BT_LOGICAL
},
67 tag_name
= {"NAME", " name =", " %v", BT_CHARACTER
},
68 tag_number
= {"NUMBER", " number =", " %v", BT_INTEGER
},
69 tag_s_access
= {"ACCESS", " access =", " %v", BT_CHARACTER
},
70 tag_sequential
= {"SEQUENTIAL", " sequential =", " %v", BT_CHARACTER
},
71 tag_direct
= {"DIRECT", " direct =", " %v", BT_CHARACTER
},
72 tag_s_form
= {"FORM", " form =", " %v", BT_CHARACTER
},
73 tag_formatted
= {"FORMATTED", " formatted =", " %v", BT_CHARACTER
},
74 tag_unformatted
= {"UNFORMATTED", " unformatted =", " %v", BT_CHARACTER
},
75 tag_s_recl
= {"RECL", " recl =", " %v", BT_INTEGER
},
76 tag_nextrec
= {"NEXTREC", " nextrec =", " %v", BT_INTEGER
},
77 tag_s_blank
= {"BLANK", " blank =", " %v", BT_CHARACTER
},
78 tag_s_position
= {"POSITION", " position =", " %v", BT_CHARACTER
},
79 tag_s_action
= {"ACTION", " action =", " %v", BT_CHARACTER
},
80 tag_read
= {"READ", " read =", " %v", BT_CHARACTER
},
81 tag_write
= {"WRITE", " write =", " %v", BT_CHARACTER
},
82 tag_readwrite
= {"READWRITE", " readwrite =", " %v", BT_CHARACTER
},
83 tag_s_delim
= {"DELIM", " delim =", " %v", BT_CHARACTER
},
84 tag_s_pad
= {"PAD", " pad =", " %v", BT_CHARACTER
},
85 tag_s_decimal
= {"DECIMAL", " decimal =", " %v", BT_CHARACTER
},
86 tag_s_encoding
= {"ENCODING", " encoding =", " %v", BT_CHARACTER
},
87 tag_s_async
= {"ASYNCHRONOUS", " asynchronous =", " %v", BT_CHARACTER
},
88 tag_s_round
= {"ROUND", " round =", " %v", BT_CHARACTER
},
89 tag_s_sign
= {"SIGN", " sign =", " %v", BT_CHARACTER
},
90 tag_iolength
= {"IOLENGTH", " iolength =", " %v", BT_INTEGER
},
91 tag_convert
= {"CONVERT", " convert =", " %e", BT_CHARACTER
},
92 tag_strm_out
= {"POS", " pos =", " %v", BT_INTEGER
},
93 tag_err
= {"ERR", " err =", " %l", BT_UNKNOWN
},
94 tag_end
= {"END", " end =", " %l", BT_UNKNOWN
},
95 tag_eor
= {"EOR", " eor =", " %l", BT_UNKNOWN
},
96 tag_id
= {"ID", " id =", " %v", BT_INTEGER
},
97 tag_pending
= {"PENDING", " pending =", " %v", BT_LOGICAL
},
98 tag_newunit
= {"NEWUNIT", " newunit =", " %v", BT_INTEGER
},
99 tag_s_iqstream
= {"STREAM", " stream =", " %v", BT_CHARACTER
};
101 static gfc_dt
*current_dt
;
103 #define RESOLVE_TAG(x, y) if (!resolve_tag (x, y)) return false;
106 /**************** Fortran 95 FORMAT parser *****************/
108 /* FORMAT tokens returned by format_lex(). */
111 FMT_NONE
, FMT_UNKNOWN
, FMT_SIGNED_INT
, FMT_ZERO
, FMT_POSINT
, FMT_PERIOD
,
112 FMT_COMMA
, FMT_COLON
, FMT_SLASH
, FMT_DOLLAR
, FMT_LPAREN
,
113 FMT_RPAREN
, FMT_X
, FMT_SIGN
, FMT_BLANK
, FMT_CHAR
, FMT_P
, FMT_IBOZ
, FMT_F
,
114 FMT_E
, FMT_EN
, FMT_ES
, FMT_G
, FMT_L
, FMT_A
, FMT_D
, FMT_H
, FMT_END
,
115 FMT_ERROR
, FMT_DC
, FMT_DP
, FMT_T
, FMT_TR
, FMT_TL
, FMT_STAR
, FMT_RC
,
116 FMT_RD
, FMT_RN
, FMT_RP
, FMT_RU
, FMT_RZ
120 /* Local variables for checking format strings. The saved_token is
121 used to back up by a single format token during the parsing
123 static gfc_char_t
*format_string
;
124 static int format_string_pos
;
125 static int format_length
, use_last_char
;
126 static char error_element
;
127 static locus format_locus
;
129 static format_token saved_token
;
132 { MODE_STRING
, MODE_FORMAT
, MODE_COPY
}
136 /* Return the next character in the format string. */
139 next_char (gfc_instring in_string
)
151 if (mode
== MODE_STRING
)
152 c
= *format_string
++;
155 c
= gfc_next_char_literal (in_string
);
160 if (flag_backslash
&& c
== '\\')
162 locus old_locus
= gfc_current_locus
;
164 if (gfc_match_special_char (&c
) == MATCH_NO
)
165 gfc_current_locus
= old_locus
;
167 if (!(gfc_option
.allow_std
& GFC_STD_GNU
) && !inhibit_warnings
)
168 gfc_warning (0, "Extension: backslash character at %C");
171 if (mode
== MODE_COPY
)
172 *format_string
++ = c
;
174 if (mode
!= MODE_STRING
)
175 format_locus
= gfc_current_locus
;
179 c
= gfc_wide_toupper (c
);
184 /* Back up one character position. Only works once. */
192 /* Eat up the spaces and return a character. */
195 next_char_not_space (bool *error
)
200 error_element
= c
= next_char (NONSTRING
);
203 if (gfc_option
.allow_std
& GFC_STD_GNU
)
204 gfc_warning (0, "Extension: Tab character in format at %C");
207 gfc_error ("Extension: Tab character in format at %C");
213 while (gfc_is_whitespace (c
));
217 static int value
= 0;
219 /* Simple lexical analyzer for getting the next token in a FORMAT
231 if (saved_token
!= FMT_NONE
)
234 saved_token
= FMT_NONE
;
238 c
= next_char_not_space (&error
);
248 c
= next_char_not_space (&error
);
259 c
= next_char_not_space (&error
);
261 value
= 10 * value
+ c
- '0';
270 token
= FMT_SIGNED_INT
;
289 c
= next_char_not_space (&error
);
292 value
= 10 * value
+ c
- '0';
300 token
= zflag
? FMT_ZERO
: FMT_POSINT
;
324 c
= next_char_not_space (&error
);
352 c
= next_char_not_space (&error
);
353 if (c
!= 'P' && c
!= 'S')
360 c
= next_char_not_space (&error
);
361 if (c
== 'N' || c
== 'Z')
379 c
= next_char (INSTRING_WARN
);
388 c
= next_char (NONSTRING
);
422 c
= next_char_not_space (&error
);
452 c
= next_char_not_space (&error
);
455 if (!gfc_notify_std (GFC_STD_F2003
, "DP format "
456 "specifier not allowed at %C"))
462 if (!gfc_notify_std (GFC_STD_F2003
, "DC format "
463 "specifier not allowed at %C"))
475 c
= next_char_not_space (&error
);
524 token_to_string (format_token t
)
543 /* Check a format statement. The format string, either from a FORMAT
544 statement or a constant in an I/O statement has already been parsed
545 by itself, and we are checking it for validity. The dual origin
546 means that the warning message is a little less than great. */
549 check_format (bool is_input
)
551 const char *posint_required
= _("Positive width required");
552 const char *nonneg_required
= _("Nonnegative width required");
553 const char *unexpected_element
= _("Unexpected element %<%c%> in format "
555 const char *unexpected_end
= _("Unexpected end of format string");
556 const char *zero_width
= _("Zero width in format descriptor");
565 saved_token
= FMT_NONE
;
569 format_string_pos
= 0;
576 error
= _("Missing leading left parenthesis");
584 goto finished
; /* Empty format is legal */
588 /* In this state, the next thing has to be a format item. */
605 error
= _("Left parenthesis required after %<*%>");
630 /* Signed integer can only precede a P format. */
636 error
= _("Expected P edit descriptor");
643 /* P requires a prior number. */
644 error
= _("P descriptor requires leading scale factor");
648 /* X requires a prior number if we're being pedantic. */
649 if (mode
!= MODE_FORMAT
)
650 format_locus
.nextc
+= format_string_pos
;
651 if (!gfc_notify_std (GFC_STD_GNU
, "X descriptor requires leading "
652 "space count at %L", &format_locus
))
669 goto extension_optional_comma
;
680 if (!gfc_notify_std (GFC_STD_GNU
, "$ descriptor at %L", &format_locus
))
682 if (t
!= FMT_RPAREN
|| level
> 0)
684 gfc_warning (0, "$ should be the last specifier in format at %L",
686 goto optional_comma_1
;
707 error
= unexpected_end
;
711 error
= unexpected_element
;
716 /* In this state, t must currently be a data descriptor.
717 Deal with things that can/must follow the descriptor. */
728 /* No comma after P allowed only for F, E, EN, ES, D, or G.
733 if (!(gfc_option
.allow_std
& GFC_STD_F2003
) && t
!= FMT_COMMA
734 && t
!= FMT_F
&& t
!= FMT_E
&& t
!= FMT_EN
&& t
!= FMT_ES
735 && t
!= FMT_D
&& t
!= FMT_G
&& t
!= FMT_RPAREN
&& t
!= FMT_SLASH
)
737 error
= _("Comma required after P descriptor");
748 if (t
!= FMT_F
&& t
!= FMT_E
&& t
!= FMT_EN
&& t
!= FMT_ES
&& t
!= FMT_D
749 && t
!= FMT_G
&& t
!= FMT_RPAREN
&& t
!= FMT_SLASH
)
751 error
= _("Comma required after P descriptor");
765 error
= _("Positive width required with T descriptor");
777 switch (gfc_notification_std (GFC_STD_GNU
))
780 if (mode
!= MODE_FORMAT
)
781 format_locus
.nextc
+= format_string_pos
;
782 gfc_warning (0, "Extension: Missing positive width after L "
783 "descriptor at %L", &format_locus
);
788 error
= posint_required
;
819 if (t
== FMT_G
&& u
== FMT_ZERO
)
826 if (!gfc_notify_std (GFC_STD_F2008
, "%<G0%> in format at %L",
838 error
= posint_required
;
844 error
= _("E specifier not allowed with g0 descriptor");
853 format_locus
.nextc
+= format_string_pos
;
854 gfc_error ("Positive width required in format "
855 "specifier %s at %L", token_to_string (t
),
866 /* Warn if -std=legacy, otherwise error. */
867 format_locus
.nextc
+= format_string_pos
;
868 if (gfc_option
.warn_std
!= 0)
870 gfc_error ("Period required in format "
871 "specifier %s at %L", token_to_string (t
),
877 gfc_warning (0, "Period required in format "
878 "specifier %s at %L", token_to_string (t
),
880 /* If we go to finished, we need to unwind this
881 before the next round. */
882 format_locus
.nextc
-= format_string_pos
;
890 if (u
!= FMT_ZERO
&& u
!= FMT_POSINT
)
892 error
= nonneg_required
;
899 /* Look for optional exponent. */
914 error
= _("Positive exponent width required");
925 if (t
!= FMT_ZERO
&& t
!= FMT_POSINT
)
927 error
= nonneg_required
;
930 else if (is_input
&& t
== FMT_ZERO
)
932 error
= posint_required
;
941 /* Warn if -std=legacy, otherwise error. */
942 if (gfc_option
.warn_std
!= 0)
944 error
= _("Period required in format specifier");
947 if (mode
!= MODE_FORMAT
)
948 format_locus
.nextc
+= format_string_pos
;
949 gfc_warning (0, "Period required in format specifier at %L",
958 if (t
!= FMT_ZERO
&& t
!= FMT_POSINT
)
960 error
= nonneg_required
;
967 if (!(gfc_option
.allow_std
& GFC_STD_GNU
) && !inhibit_warnings
)
969 if (mode
!= MODE_FORMAT
)
970 format_locus
.nextc
+= format_string_pos
;
971 gfc_warning (0, "The H format specifier at %L is"
972 " a Fortran 95 deleted feature", &format_locus
);
974 if (mode
== MODE_STRING
)
976 format_string
+= value
;
977 format_length
-= value
;
978 format_string_pos
+= repeat
;
984 next_char (INSTRING_WARN
);
994 if (t
!= FMT_ZERO
&& t
!= FMT_POSINT
)
996 error
= nonneg_required
;
999 else if (is_input
&& t
== FMT_ZERO
)
1001 error
= posint_required
;
1008 if (t
!= FMT_PERIOD
)
1017 if (t
!= FMT_ZERO
&& t
!= FMT_POSINT
)
1019 error
= nonneg_required
;
1027 error
= unexpected_element
;
1032 /* Between a descriptor and what comes next. */
1050 goto optional_comma
;
1053 error
= unexpected_end
;
1057 if (mode
!= MODE_FORMAT
)
1058 format_locus
.nextc
+= format_string_pos
- 1;
1059 if (!gfc_notify_std (GFC_STD_GNU
, "Missing comma at %L", &format_locus
))
1061 /* If we do not actually return a failure, we need to unwind this
1062 before the next round. */
1063 if (mode
!= MODE_FORMAT
)
1064 format_locus
.nextc
-= format_string_pos
;
1069 /* Optional comma is a weird between state where we've just finished
1070 reading a colon, slash, dollar or P descriptor. */
1087 /* Assume that we have another format item. */
1094 extension_optional_comma
:
1095 /* As a GNU extension, permit a missing comma after a string literal. */
1112 goto optional_comma
;
1115 error
= unexpected_end
;
1119 if (mode
!= MODE_FORMAT
)
1120 format_locus
.nextc
+= format_string_pos
;
1121 if (!gfc_notify_std (GFC_STD_GNU
, "Missing comma at %L", &format_locus
))
1123 /* If we do not actually return a failure, we need to unwind this
1124 before the next round. */
1125 if (mode
!= MODE_FORMAT
)
1126 format_locus
.nextc
-= format_string_pos
;
1134 if (mode
!= MODE_FORMAT
)
1135 format_locus
.nextc
+= format_string_pos
;
1136 if (error
== unexpected_element
)
1137 gfc_error (error
, error_element
, &format_locus
);
1139 gfc_error ("%s in format string at %L", error
, &format_locus
);
1148 /* Given an expression node that is a constant string, see if it looks
1149 like a format string. */
1152 check_format_string (gfc_expr
*e
, bool is_input
)
1156 if (!e
|| e
->ts
.type
!= BT_CHARACTER
|| e
->expr_type
!= EXPR_CONSTANT
)
1160 format_string
= e
->value
.character
.string
;
1162 /* More elaborate measures are needed to show where a problem is within a
1163 format string that has been calculated, but that's probably not worth the
1165 format_locus
= e
->where
;
1166 rv
= check_format (is_input
);
1167 /* check for extraneous characters at the end of an otherwise valid format
1168 string, like '(A10,I3)F5'
1169 start at the end and move back to the last character processed,
1171 if (rv
&& e
->value
.character
.length
> format_string_pos
)
1172 for (i
=e
->value
.character
.length
-1;i
>format_string_pos
-1;i
--)
1173 if (e
->value
.character
.string
[i
] != ' ')
1175 format_locus
.nextc
+= format_length
+ 1;
1177 "Extraneous characters in format at %L", &format_locus
);
1184 /************ Fortran 95 I/O statement matchers *************/
1186 /* Match a FORMAT statement. This amounts to actually parsing the
1187 format descriptors in order to correctly locate the end of the
1191 gfc_match_format (void)
1196 if (gfc_current_ns
->proc_name
1197 && gfc_current_ns
->proc_name
->attr
.flavor
== FL_MODULE
)
1199 gfc_error ("Format statement in module main block at %C");
1203 if (gfc_statement_label
== NULL
)
1205 gfc_error ("Missing format label at %C");
1208 gfc_gobble_whitespace ();
1213 start
= gfc_current_locus
;
1215 if (!check_format (false))
1218 if (gfc_match_eos () != MATCH_YES
)
1220 gfc_syntax_error (ST_FORMAT
);
1224 /* The label doesn't get created until after the statement is done
1225 being matched, so we have to leave the string for later. */
1227 gfc_current_locus
= start
; /* Back to the beginning */
1230 new_st
.op
= EXEC_NOP
;
1232 e
= gfc_get_character_expr (gfc_default_character_kind
, &start
,
1233 NULL
, format_length
);
1234 format_string
= e
->value
.character
.string
;
1235 gfc_statement_label
->format
= e
;
1238 check_format (false); /* Guaranteed to succeed */
1239 gfc_match_eos (); /* Guaranteed to succeed */
1245 /* Match an expression I/O tag of some sort. */
1248 match_etag (const io_tag
*tag
, gfc_expr
**v
)
1253 m
= gfc_match (tag
->spec
);
1257 m
= gfc_match (tag
->value
, &result
);
1260 gfc_error ("Invalid value for %s specification at %C", tag
->name
);
1266 gfc_error ("Duplicate %s specification at %C", tag
->name
);
1267 gfc_free_expr (result
);
1276 /* Match a variable I/O tag of some sort. */
1279 match_vtag (const io_tag
*tag
, gfc_expr
**v
)
1284 m
= gfc_match (tag
->spec
);
1288 m
= gfc_match (tag
->value
, &result
);
1291 gfc_error ("Invalid value for %s specification at %C", tag
->name
);
1297 gfc_error ("Duplicate %s specification at %C", tag
->name
);
1298 gfc_free_expr (result
);
1302 if (result
->symtree
->n
.sym
->attr
.intent
== INTENT_IN
)
1304 gfc_error ("Variable %s cannot be INTENT(IN) at %C", tag
->name
);
1305 gfc_free_expr (result
);
1309 bool impure
= gfc_impure_variable (result
->symtree
->n
.sym
);
1310 if (impure
&& gfc_pure (NULL
))
1312 gfc_error ("Variable %s cannot be assigned in PURE procedure at %C",
1314 gfc_free_expr (result
);
1319 gfc_unset_implicit_pure (NULL
);
1326 /* Match I/O tags that cause variables to become redefined. */
1329 match_out_tag (const io_tag
*tag
, gfc_expr
**result
)
1333 m
= match_vtag (tag
, result
);
1335 gfc_check_do_variable ((*result
)->symtree
);
1341 /* Match a label I/O tag. */
1344 match_ltag (const io_tag
*tag
, gfc_st_label
** label
)
1350 m
= gfc_match (tag
->spec
);
1354 m
= gfc_match (tag
->value
, label
);
1357 gfc_error ("Invalid value for %s specification at %C", tag
->name
);
1363 gfc_error ("Duplicate %s label specification at %C", tag
->name
);
1367 if (!gfc_reference_st_label (*label
, ST_LABEL_TARGET
))
1374 /* Resolution of the FORMAT tag, to be called from resolve_tag. */
1377 resolve_tag_format (const gfc_expr
*e
)
1379 if (e
->expr_type
== EXPR_CONSTANT
1380 && (e
->ts
.type
!= BT_CHARACTER
1381 || e
->ts
.kind
!= gfc_default_character_kind
))
1383 gfc_error ("Constant expression in FORMAT tag at %L must be "
1384 "of type default CHARACTER", &e
->where
);
1388 /* If e's rank is zero and e is not an element of an array, it should be
1389 of integer or character type. The integer variable should be
1392 && (e
->expr_type
!= EXPR_VARIABLE
1393 || e
->symtree
== NULL
1394 || e
->symtree
->n
.sym
->as
== NULL
1395 || e
->symtree
->n
.sym
->as
->rank
== 0))
1397 if ((e
->ts
.type
!= BT_CHARACTER
1398 || e
->ts
.kind
!= gfc_default_character_kind
)
1399 && e
->ts
.type
!= BT_INTEGER
)
1401 gfc_error ("FORMAT tag at %L must be of type default-kind CHARACTER "
1402 "or of INTEGER", &e
->where
);
1405 else if (e
->ts
.type
== BT_INTEGER
&& e
->expr_type
== EXPR_VARIABLE
)
1407 if (!gfc_notify_std (GFC_STD_F95_DEL
, "ASSIGNED variable in "
1408 "FORMAT tag at %L", &e
->where
))
1410 if (e
->symtree
->n
.sym
->attr
.assign
!= 1)
1412 gfc_error ("Variable %qs at %L has not been assigned a "
1413 "format label", e
->symtree
->n
.sym
->name
, &e
->where
);
1417 else if (e
->ts
.type
== BT_INTEGER
)
1419 gfc_error ("Scalar %qs in FORMAT tag at %L is not an ASSIGNED "
1420 "variable", gfc_basic_typename (e
->ts
.type
), &e
->where
);
1427 /* If rank is nonzero and type is not character, we allow it under GFC_STD_LEGACY.
1428 It may be assigned an Hollerith constant. */
1429 if (e
->ts
.type
!= BT_CHARACTER
)
1431 if (!gfc_notify_std (GFC_STD_LEGACY
, "Non-character in FORMAT tag "
1432 "at %L", &e
->where
))
1435 if (e
->rank
== 0 && e
->symtree
->n
.sym
->as
->type
== AS_ASSUMED_SHAPE
)
1437 gfc_error ("Non-character assumed shape array element in FORMAT"
1438 " tag at %L", &e
->where
);
1442 if (e
->rank
== 0 && e
->symtree
->n
.sym
->as
->type
== AS_ASSUMED_SIZE
)
1444 gfc_error ("Non-character assumed size array element in FORMAT"
1445 " tag at %L", &e
->where
);
1449 if (e
->rank
== 0 && e
->symtree
->n
.sym
->attr
.pointer
)
1451 gfc_error ("Non-character pointer array element in FORMAT tag at %L",
1461 /* Do expression resolution and type-checking on an expression tag. */
1464 resolve_tag (const io_tag
*tag
, gfc_expr
*e
)
1469 if (!gfc_resolve_expr (e
))
1472 if (tag
== &tag_format
)
1473 return resolve_tag_format (e
);
1475 if (e
->ts
.type
!= tag
->type
)
1477 gfc_error ("%s tag at %L must be of type %s", tag
->name
,
1478 &e
->where
, gfc_basic_typename (tag
->type
));
1482 if (e
->ts
.type
== BT_CHARACTER
&& e
->ts
.kind
!= gfc_default_character_kind
)
1484 gfc_error ("%s tag at %L must be a character string of default kind",
1485 tag
->name
, &e
->where
);
1491 gfc_error ("%s tag at %L must be scalar", tag
->name
, &e
->where
);
1495 if (tag
== &tag_iomsg
)
1497 if (!gfc_notify_std (GFC_STD_F2003
, "IOMSG tag at %L", &e
->where
))
1501 if ((tag
== &tag_iostat
|| tag
== &tag_size
|| tag
== &tag_iolength
1502 || tag
== &tag_number
|| tag
== &tag_nextrec
|| tag
== &tag_s_recl
)
1503 && e
->ts
.kind
!= gfc_default_integer_kind
)
1505 if (!gfc_notify_std (GFC_STD_F2003
, "Fortran 95 requires default "
1506 "INTEGER in %s tag at %L", tag
->name
, &e
->where
))
1510 if (e
->ts
.kind
!= gfc_default_logical_kind
&&
1511 (tag
== &tag_exist
|| tag
== &tag_named
|| tag
== &tag_opened
1512 || tag
== &tag_pending
))
1514 if (!gfc_notify_std (GFC_STD_F2008
, "Non-default LOGICAL kind "
1515 "in %s tag at %L", tag
->name
, &e
->where
))
1519 if (tag
== &tag_newunit
)
1521 if (!gfc_notify_std (GFC_STD_F2008
, "NEWUNIT specifier at %L",
1526 /* NEWUNIT, IOSTAT, SIZE and IOMSG are variable definition contexts. */
1527 if (tag
== &tag_newunit
|| tag
== &tag_iostat
1528 || tag
== &tag_size
|| tag
== &tag_iomsg
)
1532 sprintf (context
, _("%s tag"), tag
->name
);
1533 if (!gfc_check_vardef_context (e
, false, false, false, context
))
1537 if (tag
== &tag_convert
)
1539 if (!gfc_notify_std (GFC_STD_GNU
, "CONVERT tag at %L", &e
->where
))
1547 /* Match a single tag of an OPEN statement. */
1550 match_open_element (gfc_open
*open
)
1554 m
= match_etag (&tag_e_async
, &open
->asynchronous
);
1557 m
= match_etag (&tag_unit
, &open
->unit
);
1560 m
= match_out_tag (&tag_iomsg
, &open
->iomsg
);
1563 m
= match_out_tag (&tag_iostat
, &open
->iostat
);
1566 m
= match_etag (&tag_file
, &open
->file
);
1569 m
= match_etag (&tag_status
, &open
->status
);
1572 m
= match_etag (&tag_e_access
, &open
->access
);
1575 m
= match_etag (&tag_e_form
, &open
->form
);
1578 m
= match_etag (&tag_e_recl
, &open
->recl
);
1581 m
= match_etag (&tag_e_blank
, &open
->blank
);
1584 m
= match_etag (&tag_e_position
, &open
->position
);
1587 m
= match_etag (&tag_e_action
, &open
->action
);
1590 m
= match_etag (&tag_e_delim
, &open
->delim
);
1593 m
= match_etag (&tag_e_pad
, &open
->pad
);
1596 m
= match_etag (&tag_e_decimal
, &open
->decimal
);
1599 m
= match_etag (&tag_e_encoding
, &open
->encoding
);
1602 m
= match_etag (&tag_e_round
, &open
->round
);
1605 m
= match_etag (&tag_e_sign
, &open
->sign
);
1608 m
= match_ltag (&tag_err
, &open
->err
);
1611 m
= match_etag (&tag_convert
, &open
->convert
);
1614 m
= match_out_tag (&tag_newunit
, &open
->newunit
);
1622 /* Free the gfc_open structure and all the expressions it contains. */
1625 gfc_free_open (gfc_open
*open
)
1630 gfc_free_expr (open
->unit
);
1631 gfc_free_expr (open
->iomsg
);
1632 gfc_free_expr (open
->iostat
);
1633 gfc_free_expr (open
->file
);
1634 gfc_free_expr (open
->status
);
1635 gfc_free_expr (open
->access
);
1636 gfc_free_expr (open
->form
);
1637 gfc_free_expr (open
->recl
);
1638 gfc_free_expr (open
->blank
);
1639 gfc_free_expr (open
->position
);
1640 gfc_free_expr (open
->action
);
1641 gfc_free_expr (open
->delim
);
1642 gfc_free_expr (open
->pad
);
1643 gfc_free_expr (open
->decimal
);
1644 gfc_free_expr (open
->encoding
);
1645 gfc_free_expr (open
->round
);
1646 gfc_free_expr (open
->sign
);
1647 gfc_free_expr (open
->convert
);
1648 gfc_free_expr (open
->asynchronous
);
1649 gfc_free_expr (open
->newunit
);
1654 /* Resolve everything in a gfc_open structure. */
1657 gfc_resolve_open (gfc_open
*open
)
1660 RESOLVE_TAG (&tag_unit
, open
->unit
);
1661 RESOLVE_TAG (&tag_iomsg
, open
->iomsg
);
1662 RESOLVE_TAG (&tag_iostat
, open
->iostat
);
1663 RESOLVE_TAG (&tag_file
, open
->file
);
1664 RESOLVE_TAG (&tag_status
, open
->status
);
1665 RESOLVE_TAG (&tag_e_access
, open
->access
);
1666 RESOLVE_TAG (&tag_e_form
, open
->form
);
1667 RESOLVE_TAG (&tag_e_recl
, open
->recl
);
1668 RESOLVE_TAG (&tag_e_blank
, open
->blank
);
1669 RESOLVE_TAG (&tag_e_position
, open
->position
);
1670 RESOLVE_TAG (&tag_e_action
, open
->action
);
1671 RESOLVE_TAG (&tag_e_delim
, open
->delim
);
1672 RESOLVE_TAG (&tag_e_pad
, open
->pad
);
1673 RESOLVE_TAG (&tag_e_decimal
, open
->decimal
);
1674 RESOLVE_TAG (&tag_e_encoding
, open
->encoding
);
1675 RESOLVE_TAG (&tag_e_async
, open
->asynchronous
);
1676 RESOLVE_TAG (&tag_e_round
, open
->round
);
1677 RESOLVE_TAG (&tag_e_sign
, open
->sign
);
1678 RESOLVE_TAG (&tag_convert
, open
->convert
);
1679 RESOLVE_TAG (&tag_newunit
, open
->newunit
);
1681 if (!gfc_reference_st_label (open
->err
, ST_LABEL_TARGET
))
1688 /* Check if a given value for a SPECIFIER is either in the list of values
1689 allowed in F95 or F2003, issuing an error message and returning a zero
1690 value if it is not allowed. */
1693 compare_to_allowed_values (const char *specifier
, const char *allowed
[],
1694 const char *allowed_f2003
[],
1695 const char *allowed_gnu
[], gfc_char_t
*value
,
1696 const char *statement
, bool warn
)
1701 len
= gfc_wide_strlen (value
);
1704 for (len
--; len
> 0; len
--)
1705 if (value
[len
] != ' ')
1710 for (i
= 0; allowed
[i
]; i
++)
1711 if (len
== strlen (allowed
[i
])
1712 && gfc_wide_strncasecmp (value
, allowed
[i
], strlen (allowed
[i
])) == 0)
1715 for (i
= 0; allowed_f2003
&& allowed_f2003
[i
]; i
++)
1716 if (len
== strlen (allowed_f2003
[i
])
1717 && gfc_wide_strncasecmp (value
, allowed_f2003
[i
],
1718 strlen (allowed_f2003
[i
])) == 0)
1720 notification n
= gfc_notification_std (GFC_STD_F2003
);
1722 if (n
== WARNING
|| (warn
&& n
== ERROR
))
1724 gfc_warning (0, "Fortran 2003: %s specifier in %s statement at %C "
1725 "has value %qs", specifier
, statement
,
1732 gfc_notify_std (GFC_STD_F2003
, "%s specifier in "
1733 "%s statement at %C has value %qs", specifier
,
1734 statement
, allowed_f2003
[i
]);
1742 for (i
= 0; allowed_gnu
&& allowed_gnu
[i
]; i
++)
1743 if (len
== strlen (allowed_gnu
[i
])
1744 && gfc_wide_strncasecmp (value
, allowed_gnu
[i
],
1745 strlen (allowed_gnu
[i
])) == 0)
1747 notification n
= gfc_notification_std (GFC_STD_GNU
);
1749 if (n
== WARNING
|| (warn
&& n
== ERROR
))
1751 gfc_warning (0, "Extension: %s specifier in %s statement at %C "
1752 "has value %qs", specifier
, statement
,
1759 gfc_notify_std (GFC_STD_GNU
, "%s specifier in "
1760 "%s statement at %C has value %qs", specifier
,
1761 statement
, allowed_gnu
[i
]);
1771 char *s
= gfc_widechar_to_char (value
, -1);
1773 "%s specifier in %s statement at %C has invalid value %qs",
1774 specifier
, statement
, s
);
1780 char *s
= gfc_widechar_to_char (value
, -1);
1781 gfc_error ("%s specifier in %s statement at %C has invalid value %qs",
1782 specifier
, statement
, s
);
1789 /* Match an OPEN statement. */
1792 gfc_match_open (void)
1798 m
= gfc_match_char ('(');
1802 open
= XCNEW (gfc_open
);
1804 m
= match_open_element (open
);
1806 if (m
== MATCH_ERROR
)
1810 m
= gfc_match_expr (&open
->unit
);
1811 if (m
== MATCH_ERROR
)
1817 if (gfc_match_char (')') == MATCH_YES
)
1819 if (gfc_match_char (',') != MATCH_YES
)
1822 m
= match_open_element (open
);
1823 if (m
== MATCH_ERROR
)
1829 if (gfc_match_eos () == MATCH_NO
)
1832 if (gfc_pure (NULL
))
1834 gfc_error ("OPEN statement not allowed in PURE procedure at %C");
1838 gfc_unset_implicit_pure (NULL
);
1840 warn
= (open
->err
|| open
->iostat
) ? true : false;
1842 /* Checks on NEWUNIT specifier. */
1847 gfc_error ("UNIT specifier not allowed with NEWUNIT at %C");
1851 if (!(open
->file
|| (open
->status
1852 && gfc_wide_strncasecmp (open
->status
->value
.character
.string
,
1853 "scratch", 7) == 0)))
1855 gfc_error ("NEWUNIT specifier must have FILE= "
1856 "or STATUS='scratch' at %C");
1860 else if (!open
->unit
)
1862 gfc_error ("OPEN statement at %C must have UNIT or NEWUNIT specified");
1866 /* Checks on the ACCESS specifier. */
1867 if (open
->access
&& open
->access
->expr_type
== EXPR_CONSTANT
)
1869 static const char *access_f95
[] = { "SEQUENTIAL", "DIRECT", NULL
};
1870 static const char *access_f2003
[] = { "STREAM", NULL
};
1871 static const char *access_gnu
[] = { "APPEND", NULL
};
1873 if (!compare_to_allowed_values ("ACCESS", access_f95
, access_f2003
,
1875 open
->access
->value
.character
.string
,
1880 /* Checks on the ACTION specifier. */
1881 if (open
->action
&& open
->action
->expr_type
== EXPR_CONSTANT
)
1883 static const char *action
[] = { "READ", "WRITE", "READWRITE", NULL
};
1885 if (!compare_to_allowed_values ("ACTION", action
, NULL
, NULL
,
1886 open
->action
->value
.character
.string
,
1891 /* Checks on the ASYNCHRONOUS specifier. */
1892 if (open
->asynchronous
)
1894 if (!gfc_notify_std (GFC_STD_F2003
, "ASYNCHRONOUS= at %C "
1895 "not allowed in Fortran 95"))
1898 if (open
->asynchronous
->expr_type
== EXPR_CONSTANT
)
1900 static const char * asynchronous
[] = { "YES", "NO", NULL
};
1902 if (!compare_to_allowed_values ("ASYNCHRONOUS", asynchronous
,
1903 NULL
, NULL
, open
->asynchronous
->value
.character
.string
,
1909 /* Checks on the BLANK specifier. */
1912 if (!gfc_notify_std (GFC_STD_F2003
, "BLANK= at %C "
1913 "not allowed in Fortran 95"))
1916 if (open
->blank
->expr_type
== EXPR_CONSTANT
)
1918 static const char *blank
[] = { "ZERO", "NULL", NULL
};
1920 if (!compare_to_allowed_values ("BLANK", blank
, NULL
, NULL
,
1921 open
->blank
->value
.character
.string
,
1927 /* Checks on the DECIMAL specifier. */
1930 if (!gfc_notify_std (GFC_STD_F2003
, "DECIMAL= at %C "
1931 "not allowed in Fortran 95"))
1934 if (open
->decimal
->expr_type
== EXPR_CONSTANT
)
1936 static const char * decimal
[] = { "COMMA", "POINT", NULL
};
1938 if (!compare_to_allowed_values ("DECIMAL", decimal
, NULL
, NULL
,
1939 open
->decimal
->value
.character
.string
,
1945 /* Checks on the DELIM specifier. */
1948 if (open
->delim
->expr_type
== EXPR_CONSTANT
)
1950 static const char *delim
[] = { "APOSTROPHE", "QUOTE", "NONE", NULL
};
1952 if (!compare_to_allowed_values ("DELIM", delim
, NULL
, NULL
,
1953 open
->delim
->value
.character
.string
,
1959 /* Checks on the ENCODING specifier. */
1962 if (!gfc_notify_std (GFC_STD_F2003
, "ENCODING= at %C "
1963 "not allowed in Fortran 95"))
1966 if (open
->encoding
->expr_type
== EXPR_CONSTANT
)
1968 static const char * encoding
[] = { "DEFAULT", "UTF-8", NULL
};
1970 if (!compare_to_allowed_values ("ENCODING", encoding
, NULL
, NULL
,
1971 open
->encoding
->value
.character
.string
,
1977 /* Checks on the FORM specifier. */
1978 if (open
->form
&& open
->form
->expr_type
== EXPR_CONSTANT
)
1980 static const char *form
[] = { "FORMATTED", "UNFORMATTED", NULL
};
1982 if (!compare_to_allowed_values ("FORM", form
, NULL
, NULL
,
1983 open
->form
->value
.character
.string
,
1988 /* Checks on the PAD specifier. */
1989 if (open
->pad
&& open
->pad
->expr_type
== EXPR_CONSTANT
)
1991 static const char *pad
[] = { "YES", "NO", NULL
};
1993 if (!compare_to_allowed_values ("PAD", pad
, NULL
, NULL
,
1994 open
->pad
->value
.character
.string
,
1999 /* Checks on the POSITION specifier. */
2000 if (open
->position
&& open
->position
->expr_type
== EXPR_CONSTANT
)
2002 static const char *position
[] = { "ASIS", "REWIND", "APPEND", NULL
};
2004 if (!compare_to_allowed_values ("POSITION", position
, NULL
, NULL
,
2005 open
->position
->value
.character
.string
,
2010 /* Checks on the ROUND specifier. */
2013 if (!gfc_notify_std (GFC_STD_F2003
, "ROUND= at %C "
2014 "not allowed in Fortran 95"))
2017 if (open
->round
->expr_type
== EXPR_CONSTANT
)
2019 static const char * round
[] = { "UP", "DOWN", "ZERO", "NEAREST",
2020 "COMPATIBLE", "PROCESSOR_DEFINED",
2023 if (!compare_to_allowed_values ("ROUND", round
, NULL
, NULL
,
2024 open
->round
->value
.character
.string
,
2030 /* Checks on the SIGN specifier. */
2033 if (!gfc_notify_std (GFC_STD_F2003
, "SIGN= at %C "
2034 "not allowed in Fortran 95"))
2037 if (open
->sign
->expr_type
== EXPR_CONSTANT
)
2039 static const char * sign
[] = { "PLUS", "SUPPRESS", "PROCESSOR_DEFINED",
2042 if (!compare_to_allowed_values ("SIGN", sign
, NULL
, NULL
,
2043 open
->sign
->value
.character
.string
,
2049 #define warn_or_error(...) \
2052 gfc_warning (0, __VA_ARGS__); \
2055 gfc_error (__VA_ARGS__); \
2060 /* Checks on the RECL specifier. */
2061 if (open
->recl
&& open
->recl
->expr_type
== EXPR_CONSTANT
2062 && open
->recl
->ts
.type
== BT_INTEGER
2063 && mpz_sgn (open
->recl
->value
.integer
) != 1)
2065 warn_or_error ("RECL in OPEN statement at %C must be positive");
2068 /* Checks on the STATUS specifier. */
2069 if (open
->status
&& open
->status
->expr_type
== EXPR_CONSTANT
)
2071 static const char *status
[] = { "OLD", "NEW", "SCRATCH",
2072 "REPLACE", "UNKNOWN", NULL
};
2074 if (!compare_to_allowed_values ("STATUS", status
, NULL
, NULL
,
2075 open
->status
->value
.character
.string
,
2079 /* F2003, 9.4.5: If the STATUS= specifier has the value NEW or REPLACE,
2080 the FILE= specifier shall appear. */
2081 if (open
->file
== NULL
2082 && (gfc_wide_strncasecmp (open
->status
->value
.character
.string
,
2084 || gfc_wide_strncasecmp (open
->status
->value
.character
.string
,
2087 char *s
= gfc_widechar_to_char (open
->status
->value
.character
.string
,
2089 warn_or_error ("The STATUS specified in OPEN statement at %C is "
2090 "%qs and no FILE specifier is present", s
);
2094 /* F2003, 9.4.5: If the STATUS= specifier has the value SCRATCH,
2095 the FILE= specifier shall not appear. */
2096 if (gfc_wide_strncasecmp (open
->status
->value
.character
.string
,
2097 "scratch", 7) == 0 && open
->file
)
2099 warn_or_error ("The STATUS specified in OPEN statement at %C "
2100 "cannot have the value SCRATCH if a FILE specifier "
2105 /* Things that are not allowed for unformatted I/O. */
2106 if (open
->form
&& open
->form
->expr_type
== EXPR_CONSTANT
2107 && (open
->delim
|| open
->decimal
|| open
->encoding
|| open
->round
2108 || open
->sign
|| open
->pad
|| open
->blank
)
2109 && gfc_wide_strncasecmp (open
->form
->value
.character
.string
,
2110 "unformatted", 11) == 0)
2112 const char *spec
= (open
->delim
? "DELIM "
2113 : (open
->pad
? "PAD " : open
->blank
2116 warn_or_error ("%s specifier at %C not allowed in OPEN statement for "
2117 "unformatted I/O", spec
);
2120 if (open
->recl
&& open
->access
&& open
->access
->expr_type
== EXPR_CONSTANT
2121 && gfc_wide_strncasecmp (open
->access
->value
.character
.string
,
2124 warn_or_error ("RECL specifier not allowed in OPEN statement at %C for "
2129 && open
->access
&& open
->access
->expr_type
== EXPR_CONSTANT
2130 && !(gfc_wide_strncasecmp (open
->access
->value
.character
.string
,
2131 "sequential", 10) == 0
2132 || gfc_wide_strncasecmp (open
->access
->value
.character
.string
,
2134 || gfc_wide_strncasecmp (open
->access
->value
.character
.string
,
2137 warn_or_error ("POSITION specifier in OPEN statement at %C only allowed "
2138 "for stream or sequential ACCESS");
2141 #undef warn_or_error
2143 new_st
.op
= EXEC_OPEN
;
2144 new_st
.ext
.open
= open
;
2148 gfc_syntax_error (ST_OPEN
);
2151 gfc_free_open (open
);
2156 /* Free a gfc_close structure an all its expressions. */
2159 gfc_free_close (gfc_close
*close
)
2164 gfc_free_expr (close
->unit
);
2165 gfc_free_expr (close
->iomsg
);
2166 gfc_free_expr (close
->iostat
);
2167 gfc_free_expr (close
->status
);
2172 /* Match elements of a CLOSE statement. */
2175 match_close_element (gfc_close
*close
)
2179 m
= match_etag (&tag_unit
, &close
->unit
);
2182 m
= match_etag (&tag_status
, &close
->status
);
2185 m
= match_out_tag (&tag_iomsg
, &close
->iomsg
);
2188 m
= match_out_tag (&tag_iostat
, &close
->iostat
);
2191 m
= match_ltag (&tag_err
, &close
->err
);
2199 /* Match a CLOSE statement. */
2202 gfc_match_close (void)
2208 m
= gfc_match_char ('(');
2212 close
= XCNEW (gfc_close
);
2214 m
= match_close_element (close
);
2216 if (m
== MATCH_ERROR
)
2220 m
= gfc_match_expr (&close
->unit
);
2223 if (m
== MATCH_ERROR
)
2229 if (gfc_match_char (')') == MATCH_YES
)
2231 if (gfc_match_char (',') != MATCH_YES
)
2234 m
= match_close_element (close
);
2235 if (m
== MATCH_ERROR
)
2241 if (gfc_match_eos () == MATCH_NO
)
2244 if (gfc_pure (NULL
))
2246 gfc_error ("CLOSE statement not allowed in PURE procedure at %C");
2250 gfc_unset_implicit_pure (NULL
);
2252 warn
= (close
->iostat
|| close
->err
) ? true : false;
2254 /* Checks on the STATUS specifier. */
2255 if (close
->status
&& close
->status
->expr_type
== EXPR_CONSTANT
)
2257 static const char *status
[] = { "KEEP", "DELETE", NULL
};
2259 if (!compare_to_allowed_values ("STATUS", status
, NULL
, NULL
,
2260 close
->status
->value
.character
.string
,
2265 new_st
.op
= EXEC_CLOSE
;
2266 new_st
.ext
.close
= close
;
2270 gfc_syntax_error (ST_CLOSE
);
2273 gfc_free_close (close
);
2278 /* Resolve everything in a gfc_close structure. */
2281 gfc_resolve_close (gfc_close
*close
)
2283 RESOLVE_TAG (&tag_unit
, close
->unit
);
2284 RESOLVE_TAG (&tag_iomsg
, close
->iomsg
);
2285 RESOLVE_TAG (&tag_iostat
, close
->iostat
);
2286 RESOLVE_TAG (&tag_status
, close
->status
);
2288 if (!gfc_reference_st_label (close
->err
, ST_LABEL_TARGET
))
2291 if (close
->unit
== NULL
)
2293 /* Find a locus from one of the arguments to close, when UNIT is
2295 locus loc
= gfc_current_locus
;
2297 loc
= close
->status
->where
;
2298 else if (close
->iostat
)
2299 loc
= close
->iostat
->where
;
2300 else if (close
->iomsg
)
2301 loc
= close
->iomsg
->where
;
2302 else if (close
->err
)
2303 loc
= close
->err
->where
;
2305 gfc_error ("CLOSE statement at %L requires a UNIT number", &loc
);
2309 if (close
->unit
->expr_type
== EXPR_CONSTANT
2310 && close
->unit
->ts
.type
== BT_INTEGER
2311 && mpz_sgn (close
->unit
->value
.integer
) < 0)
2313 gfc_error ("UNIT number in CLOSE statement at %L must be non-negative",
2314 &close
->unit
->where
);
2321 /* Free a gfc_filepos structure. */
2324 gfc_free_filepos (gfc_filepos
*fp
)
2326 gfc_free_expr (fp
->unit
);
2327 gfc_free_expr (fp
->iomsg
);
2328 gfc_free_expr (fp
->iostat
);
2333 /* Match elements of a REWIND, BACKSPACE, ENDFILE, or FLUSH statement. */
2336 match_file_element (gfc_filepos
*fp
)
2340 m
= match_etag (&tag_unit
, &fp
->unit
);
2343 m
= match_out_tag (&tag_iomsg
, &fp
->iomsg
);
2346 m
= match_out_tag (&tag_iostat
, &fp
->iostat
);
2349 m
= match_ltag (&tag_err
, &fp
->err
);
2357 /* Match the second half of the file-positioning statements, REWIND,
2358 BACKSPACE, ENDFILE, or the FLUSH statement. */
2361 match_filepos (gfc_statement st
, gfc_exec_op op
)
2366 fp
= XCNEW (gfc_filepos
);
2368 if (gfc_match_char ('(') == MATCH_NO
)
2370 m
= gfc_match_expr (&fp
->unit
);
2371 if (m
== MATCH_ERROR
)
2379 m
= match_file_element (fp
);
2380 if (m
== MATCH_ERROR
)
2384 m
= gfc_match_expr (&fp
->unit
);
2385 if (m
== MATCH_ERROR
|| m
== MATCH_NO
)
2391 if (gfc_match_char (')') == MATCH_YES
)
2393 if (gfc_match_char (',') != MATCH_YES
)
2396 m
= match_file_element (fp
);
2397 if (m
== MATCH_ERROR
)
2404 if (gfc_match_eos () != MATCH_YES
)
2407 if (gfc_pure (NULL
))
2409 gfc_error ("%s statement not allowed in PURE procedure at %C",
2410 gfc_ascii_statement (st
));
2415 gfc_unset_implicit_pure (NULL
);
2418 new_st
.ext
.filepos
= fp
;
2422 gfc_syntax_error (st
);
2425 gfc_free_filepos (fp
);
2431 gfc_resolve_filepos (gfc_filepos
*fp
)
2433 RESOLVE_TAG (&tag_unit
, fp
->unit
);
2434 RESOLVE_TAG (&tag_iostat
, fp
->iostat
);
2435 RESOLVE_TAG (&tag_iomsg
, fp
->iomsg
);
2436 if (!gfc_reference_st_label (fp
->err
, ST_LABEL_TARGET
))
2439 if (fp
->unit
->expr_type
== EXPR_CONSTANT
2440 && fp
->unit
->ts
.type
== BT_INTEGER
2441 && mpz_sgn (fp
->unit
->value
.integer
) < 0)
2443 gfc_error ("UNIT number in statement at %L must be non-negative",
2451 /* Match the file positioning statements: ENDFILE, BACKSPACE, REWIND,
2452 and the FLUSH statement. */
2455 gfc_match_endfile (void)
2457 return match_filepos (ST_END_FILE
, EXEC_ENDFILE
);
2461 gfc_match_backspace (void)
2463 return match_filepos (ST_BACKSPACE
, EXEC_BACKSPACE
);
2467 gfc_match_rewind (void)
2469 return match_filepos (ST_REWIND
, EXEC_REWIND
);
2473 gfc_match_flush (void)
2475 if (!gfc_notify_std (GFC_STD_F2003
, "FLUSH statement at %C"))
2478 return match_filepos (ST_FLUSH
, EXEC_FLUSH
);
2481 /******************** Data Transfer Statements *********************/
2483 /* Return a default unit number. */
2486 default_unit (io_kind k
)
2495 return gfc_get_int_expr (gfc_default_integer_kind
, NULL
, unit
);
2499 /* Match a unit specification for a data transfer statement. */
2502 match_dt_unit (io_kind k
, gfc_dt
*dt
)
2506 if (gfc_match_char ('*') == MATCH_YES
)
2508 if (dt
->io_unit
!= NULL
)
2511 dt
->io_unit
= default_unit (k
);
2515 if (gfc_match_expr (&e
) == MATCH_YES
)
2517 if (dt
->io_unit
!= NULL
)
2530 gfc_error ("Duplicate UNIT specification at %C");
2535 /* Match a format specification. */
2538 match_dt_format (gfc_dt
*dt
)
2542 gfc_st_label
*label
;
2545 where
= gfc_current_locus
;
2547 if (gfc_match_char ('*') == MATCH_YES
)
2549 if (dt
->format_expr
!= NULL
|| dt
->format_label
!= NULL
)
2552 dt
->format_label
= &format_asterisk
;
2556 if ((m
= gfc_match_st_label (&label
)) == MATCH_YES
)
2560 /* Need to check if the format label is actually either an operand
2561 to a user-defined operator or is a kind type parameter. That is,
2562 print 2.ip.8 ! .ip. is a user-defined operator return CHARACTER.
2563 print 1_'(I0)', i ! 1_'(I0)' is a default character string. */
2565 gfc_gobble_whitespace ();
2566 c
= gfc_peek_ascii_char ();
2567 if (c
== '.' || c
== '_')
2568 gfc_current_locus
= where
;
2571 if (dt
->format_expr
!= NULL
|| dt
->format_label
!= NULL
)
2573 gfc_free_st_label (label
);
2577 if (!gfc_reference_st_label (label
, ST_LABEL_FORMAT
))
2580 dt
->format_label
= label
;
2584 else if (m
== MATCH_ERROR
)
2585 /* The label was zero or too large. Emit the correct diagnosis. */
2588 if (gfc_match_expr (&e
) == MATCH_YES
)
2590 if (dt
->format_expr
!= NULL
|| dt
->format_label
!= NULL
)
2595 dt
->format_expr
= e
;
2599 gfc_current_locus
= where
; /* The only case where we have to restore */
2604 gfc_error ("Duplicate format specification at %C");
2609 /* Traverse a namelist that is part of a READ statement to make sure
2610 that none of the variables in the namelist are INTENT(IN). Returns
2611 nonzero if we find such a variable. */
2614 check_namelist (gfc_symbol
*sym
)
2618 for (p
= sym
->namelist
; p
; p
= p
->next
)
2619 if (p
->sym
->attr
.intent
== INTENT_IN
)
2621 gfc_error ("Symbol %qs in namelist %qs is INTENT(IN) at %C",
2622 p
->sym
->name
, sym
->name
);
2630 /* Match a single data transfer element. */
2633 match_dt_element (io_kind k
, gfc_dt
*dt
)
2635 char name
[GFC_MAX_SYMBOL_LEN
+ 1];
2639 if (gfc_match (" unit =") == MATCH_YES
)
2641 m
= match_dt_unit (k
, dt
);
2646 if (gfc_match (" fmt =") == MATCH_YES
)
2648 m
= match_dt_format (dt
);
2653 if (gfc_match (" nml = %n", name
) == MATCH_YES
)
2655 if (dt
->namelist
!= NULL
)
2657 gfc_error ("Duplicate NML specification at %C");
2661 if (gfc_find_symbol (name
, NULL
, 1, &sym
))
2664 if (sym
== NULL
|| sym
->attr
.flavor
!= FL_NAMELIST
)
2666 gfc_error ("Symbol %qs at %C must be a NAMELIST group name",
2667 sym
!= NULL
? sym
->name
: name
);
2672 if (k
== M_READ
&& check_namelist (sym
))
2678 m
= match_etag (&tag_e_async
, &dt
->asynchronous
);
2681 m
= match_etag (&tag_e_blank
, &dt
->blank
);
2684 m
= match_etag (&tag_e_delim
, &dt
->delim
);
2687 m
= match_etag (&tag_e_pad
, &dt
->pad
);
2690 m
= match_etag (&tag_e_sign
, &dt
->sign
);
2693 m
= match_etag (&tag_e_round
, &dt
->round
);
2696 m
= match_out_tag (&tag_id
, &dt
->id
);
2699 m
= match_etag (&tag_e_decimal
, &dt
->decimal
);
2702 m
= match_etag (&tag_rec
, &dt
->rec
);
2705 m
= match_etag (&tag_spos
, &dt
->pos
);
2708 m
= match_out_tag (&tag_iomsg
, &dt
->iomsg
);
2711 m
= match_out_tag (&tag_iostat
, &dt
->iostat
);
2714 m
= match_ltag (&tag_err
, &dt
->err
);
2716 dt
->err_where
= gfc_current_locus
;
2719 m
= match_etag (&tag_advance
, &dt
->advance
);
2722 m
= match_out_tag (&tag_size
, &dt
->size
);
2726 m
= match_ltag (&tag_end
, &dt
->end
);
2731 gfc_error ("END tag at %C not allowed in output statement");
2734 dt
->end_where
= gfc_current_locus
;
2739 m
= match_ltag (&tag_eor
, &dt
->eor
);
2741 dt
->eor_where
= gfc_current_locus
;
2749 /* Free a data transfer structure and everything below it. */
2752 gfc_free_dt (gfc_dt
*dt
)
2757 gfc_free_expr (dt
->io_unit
);
2758 gfc_free_expr (dt
->format_expr
);
2759 gfc_free_expr (dt
->rec
);
2760 gfc_free_expr (dt
->advance
);
2761 gfc_free_expr (dt
->iomsg
);
2762 gfc_free_expr (dt
->iostat
);
2763 gfc_free_expr (dt
->size
);
2764 gfc_free_expr (dt
->pad
);
2765 gfc_free_expr (dt
->delim
);
2766 gfc_free_expr (dt
->sign
);
2767 gfc_free_expr (dt
->round
);
2768 gfc_free_expr (dt
->blank
);
2769 gfc_free_expr (dt
->decimal
);
2770 gfc_free_expr (dt
->pos
);
2771 gfc_free_expr (dt
->dt_io_kind
);
2772 /* dt->extra_comma is a link to dt_io_kind if it is set. */
2777 /* Resolve everything in a gfc_dt structure. */
2780 gfc_resolve_dt (gfc_dt
*dt
, locus
*loc
)
2785 /* This is set in any case. */
2786 gcc_assert (dt
->dt_io_kind
);
2787 k
= dt
->dt_io_kind
->value
.iokind
;
2789 RESOLVE_TAG (&tag_format
, dt
->format_expr
);
2790 RESOLVE_TAG (&tag_rec
, dt
->rec
);
2791 RESOLVE_TAG (&tag_spos
, dt
->pos
);
2792 RESOLVE_TAG (&tag_advance
, dt
->advance
);
2793 RESOLVE_TAG (&tag_id
, dt
->id
);
2794 RESOLVE_TAG (&tag_iomsg
, dt
->iomsg
);
2795 RESOLVE_TAG (&tag_iostat
, dt
->iostat
);
2796 RESOLVE_TAG (&tag_size
, dt
->size
);
2797 RESOLVE_TAG (&tag_e_pad
, dt
->pad
);
2798 RESOLVE_TAG (&tag_e_delim
, dt
->delim
);
2799 RESOLVE_TAG (&tag_e_sign
, dt
->sign
);
2800 RESOLVE_TAG (&tag_e_round
, dt
->round
);
2801 RESOLVE_TAG (&tag_e_blank
, dt
->blank
);
2802 RESOLVE_TAG (&tag_e_decimal
, dt
->decimal
);
2803 RESOLVE_TAG (&tag_e_async
, dt
->asynchronous
);
2808 gfc_error ("UNIT not specified at %L", loc
);
2812 if (gfc_resolve_expr (e
)
2813 && (e
->ts
.type
!= BT_INTEGER
2814 && (e
->ts
.type
!= BT_CHARACTER
|| e
->expr_type
!= EXPR_VARIABLE
)))
2816 /* If there is no extra comma signifying the "format" form of the IO
2817 statement, then this must be an error. */
2818 if (!dt
->extra_comma
)
2820 gfc_error ("UNIT specification at %L must be an INTEGER expression "
2821 "or a CHARACTER variable", &e
->where
);
2826 /* At this point, we have an extra comma. If io_unit has arrived as
2827 type character, we assume its really the "format" form of the I/O
2828 statement. We set the io_unit to the default unit and format to
2829 the character expression. See F95 Standard section 9.4. */
2830 if (e
->ts
.type
== BT_CHARACTER
&& (k
== M_READ
|| k
== M_PRINT
))
2832 dt
->format_expr
= dt
->io_unit
;
2833 dt
->io_unit
= default_unit (k
);
2835 /* Nullify this pointer now so that a warning/error is not
2836 triggered below for the "Extension". */
2837 dt
->extra_comma
= NULL
;
2842 gfc_error ("Invalid form of WRITE statement at %L, UNIT required",
2843 &dt
->extra_comma
->where
);
2849 if (e
->ts
.type
== BT_CHARACTER
)
2851 if (gfc_has_vector_index (e
))
2853 gfc_error ("Internal unit with vector subscript at %L", &e
->where
);
2857 /* If we are writing, make sure the internal unit can be changed. */
2858 gcc_assert (k
!= M_PRINT
);
2860 && !gfc_check_vardef_context (e
, false, false, false,
2861 _("internal unit in WRITE")))
2865 if (e
->rank
&& e
->ts
.type
!= BT_CHARACTER
)
2867 gfc_error ("External IO UNIT cannot be an array at %L", &e
->where
);
2871 if (e
->expr_type
== EXPR_CONSTANT
&& e
->ts
.type
== BT_INTEGER
2872 && mpz_sgn (e
->value
.integer
) < 0)
2874 gfc_error ("UNIT number in statement at %L must be non-negative",
2879 /* If we are reading and have a namelist, check that all namelist symbols
2880 can appear in a variable definition context. */
2881 if (k
== M_READ
&& dt
->namelist
)
2884 for (n
= dt
->namelist
->namelist
; n
; n
= n
->next
)
2889 e
= gfc_get_variable_expr (gfc_find_sym_in_symtree (n
->sym
));
2890 t
= gfc_check_vardef_context (e
, false, false, false, NULL
);
2895 gfc_error ("NAMELIST %qs in READ statement at %L contains"
2896 " the symbol %qs which may not appear in a"
2897 " variable definition context",
2898 dt
->namelist
->name
, loc
, n
->sym
->name
);
2905 && !gfc_notify_std (GFC_STD_GNU
, "Comma before i/o item list at %L",
2906 &dt
->extra_comma
->where
))
2911 if (!gfc_reference_st_label (dt
->err
, ST_LABEL_TARGET
))
2913 if (dt
->err
->defined
== ST_LABEL_UNKNOWN
)
2915 gfc_error ("ERR tag label %d at %L not defined",
2916 dt
->err
->value
, &dt
->err_where
);
2923 if (!gfc_reference_st_label (dt
->end
, ST_LABEL_TARGET
))
2925 if (dt
->end
->defined
== ST_LABEL_UNKNOWN
)
2927 gfc_error ("END tag label %d at %L not defined",
2928 dt
->end
->value
, &dt
->end_where
);
2935 if (!gfc_reference_st_label (dt
->eor
, ST_LABEL_TARGET
))
2937 if (dt
->eor
->defined
== ST_LABEL_UNKNOWN
)
2939 gfc_error ("EOR tag label %d at %L not defined",
2940 dt
->eor
->value
, &dt
->eor_where
);
2945 /* Check the format label actually exists. */
2946 if (dt
->format_label
&& dt
->format_label
!= &format_asterisk
2947 && dt
->format_label
->defined
== ST_LABEL_UNKNOWN
)
2949 gfc_error ("FORMAT label %d at %L not defined", dt
->format_label
->value
,
2950 &dt
->format_label
->where
);
2958 /* Given an io_kind, return its name. */
2961 io_kind_name (io_kind k
)
2980 gfc_internal_error ("io_kind_name(): bad I/O-kind");
2987 /* Match an IO iteration statement of the form:
2989 ( [<IO element> ,] <IO element>, I = <expr>, <expr> [, <expr> ] )
2991 which is equivalent to a single IO element. This function is
2992 mutually recursive with match_io_element(). */
2994 static match
match_io_element (io_kind
, gfc_code
**);
2997 match_io_iterator (io_kind k
, gfc_code
**result
)
2999 gfc_code
*head
, *tail
, *new_code
;
3007 old_loc
= gfc_current_locus
;
3009 if (gfc_match_char ('(') != MATCH_YES
)
3012 m
= match_io_element (k
, &head
);
3015 if (m
!= MATCH_YES
|| gfc_match_char (',') != MATCH_YES
)
3021 /* Can't be anything but an IO iterator. Build a list. */
3022 iter
= gfc_get_iterator ();
3026 m
= gfc_match_iterator (iter
, 0);
3027 if (m
== MATCH_ERROR
)
3031 gfc_check_do_variable (iter
->var
->symtree
);
3035 m
= match_io_element (k
, &new_code
);
3036 if (m
== MATCH_ERROR
)
3045 tail
= gfc_append_code (tail
, new_code
);
3047 if (gfc_match_char (',') != MATCH_YES
)
3056 if (gfc_match_char (')') != MATCH_YES
)
3059 new_code
= gfc_get_code (EXEC_DO
);
3060 new_code
->ext
.iterator
= iter
;
3062 new_code
->block
= gfc_get_code (EXEC_DO
);
3063 new_code
->block
->next
= head
;
3069 gfc_error ("Syntax error in I/O iterator at %C");
3073 gfc_free_iterator (iter
, 1);
3074 gfc_free_statements (head
);
3075 gfc_current_locus
= old_loc
;
3080 /* Match a single element of an IO list, which is either a single
3081 expression or an IO Iterator. */
3084 match_io_element (io_kind k
, gfc_code
**cpp
)
3092 m
= match_io_iterator (k
, cpp
);
3098 m
= gfc_match_variable (&expr
, 0);
3100 gfc_error ("Expected variable in READ statement at %C");
3104 m
= gfc_match_expr (&expr
);
3106 gfc_error ("Expected expression in %s statement at %C",
3110 if (m
== MATCH_YES
&& k
== M_READ
&& gfc_check_do_variable (expr
->symtree
))
3115 gfc_free_expr (expr
);
3119 cp
= gfc_get_code (EXEC_TRANSFER
);
3122 cp
->ext
.dt
= current_dt
;
3129 /* Match an I/O list, building gfc_code structures as we go. */
3132 match_io_list (io_kind k
, gfc_code
**head_p
)
3134 gfc_code
*head
, *tail
, *new_code
;
3137 *head_p
= head
= tail
= NULL
;
3138 if (gfc_match_eos () == MATCH_YES
)
3143 m
= match_io_element (k
, &new_code
);
3144 if (m
== MATCH_ERROR
)
3149 tail
= gfc_append_code (tail
, new_code
);
3153 if (gfc_match_eos () == MATCH_YES
)
3155 if (gfc_match_char (',') != MATCH_YES
)
3163 gfc_error ("Syntax error in %s statement at %C", io_kind_name (k
));
3166 gfc_free_statements (head
);
3171 /* Attach the data transfer end node. */
3174 terminate_io (gfc_code
*io_code
)
3178 if (io_code
== NULL
)
3179 io_code
= new_st
.block
;
3181 c
= gfc_get_code (EXEC_DT_END
);
3183 /* Point to structure that is already there */
3184 c
->ext
.dt
= new_st
.ext
.dt
;
3185 gfc_append_code (io_code
, c
);
3189 /* Check the constraints for a data transfer statement. The majority of the
3190 constraints appearing in 9.4 of the standard appear here. Some are handled
3191 in resolve_tag and others in gfc_resolve_dt. */
3194 check_io_constraints (io_kind k
, gfc_dt
*dt
, gfc_code
*io_code
,
3197 #define io_constraint(condition,msg,arg)\
3200 gfc_error(msg,arg);\
3206 gfc_symbol
*sym
= NULL
;
3207 bool warn
, unformatted
;
3209 warn
= (dt
->err
|| dt
->iostat
) ? true : false;
3210 unformatted
= dt
->format_expr
== NULL
&& dt
->format_label
== NULL
3211 && dt
->namelist
== NULL
;
3216 if (expr
&& expr
->expr_type
== EXPR_VARIABLE
3217 && expr
->ts
.type
== BT_CHARACTER
)
3219 sym
= expr
->symtree
->n
.sym
;
3221 io_constraint (k
== M_WRITE
&& sym
->attr
.intent
== INTENT_IN
,
3222 "Internal file at %L must not be INTENT(IN)",
3225 io_constraint (gfc_has_vector_index (dt
->io_unit
),
3226 "Internal file incompatible with vector subscript at %L",
3229 io_constraint (dt
->rec
!= NULL
,
3230 "REC tag at %L is incompatible with internal file",
3233 io_constraint (dt
->pos
!= NULL
,
3234 "POS tag at %L is incompatible with internal file",
3237 io_constraint (unformatted
,
3238 "Unformatted I/O not allowed with internal unit at %L",
3239 &dt
->io_unit
->where
);
3241 io_constraint (dt
->asynchronous
!= NULL
,
3242 "ASYNCHRONOUS tag at %L not allowed with internal file",
3243 &dt
->asynchronous
->where
);
3245 if (dt
->namelist
!= NULL
)
3247 if (!gfc_notify_std (GFC_STD_F2003
, "Internal file at %L with "
3248 "namelist", &expr
->where
))
3252 io_constraint (dt
->advance
!= NULL
,
3253 "ADVANCE tag at %L is incompatible with internal file",
3254 &dt
->advance
->where
);
3257 if (expr
&& expr
->ts
.type
!= BT_CHARACTER
)
3260 io_constraint (gfc_pure (NULL
) && (k
== M_READ
|| k
== M_WRITE
),
3261 "IO UNIT in %s statement at %C must be "
3262 "an internal file in a PURE procedure",
3265 if (k
== M_READ
|| k
== M_WRITE
)
3266 gfc_unset_implicit_pure (NULL
);
3271 io_constraint (dt
->end
, "END tag not allowed with output at %L",
3274 io_constraint (dt
->eor
, "EOR tag not allowed with output at %L",
3277 io_constraint (dt
->blank
, "BLANK= specifier not allowed with output at %L",
3280 io_constraint (dt
->pad
, "PAD= specifier not allowed with output at %L",
3283 io_constraint (dt
->size
, "SIZE= specifier not allowed with output at %L",
3288 io_constraint (dt
->size
&& dt
->advance
== NULL
,
3289 "SIZE tag at %L requires an ADVANCE tag",
3292 io_constraint (dt
->eor
&& dt
->advance
== NULL
,
3293 "EOR tag at %L requires an ADVANCE tag",
3297 if (dt
->asynchronous
)
3299 static const char * asynchronous
[] = { "YES", "NO", NULL
};
3301 if (!gfc_reduce_init_expr (dt
->asynchronous
))
3303 gfc_error ("ASYNCHRONOUS= specifier at %L must be an initialization "
3304 "expression", &dt
->asynchronous
->where
);
3308 if (!compare_to_allowed_values
3309 ("ASYNCHRONOUS", asynchronous
, NULL
, NULL
,
3310 dt
->asynchronous
->value
.character
.string
,
3311 io_kind_name (k
), warn
))
3319 || gfc_wide_strlen (dt
->asynchronous
->value
.character
.string
) != 3
3320 || gfc_wide_strncasecmp (dt
->asynchronous
->value
.character
.string
,
3322 io_constraint (not_yes
,
3323 "ID= specifier at %L must be with ASYNCHRONOUS='yes' "
3324 "specifier", &dt
->id
->where
);
3329 if (!gfc_notify_std (GFC_STD_F2003
, "DECIMAL= at %C "
3330 "not allowed in Fortran 95"))
3333 if (dt
->decimal
->expr_type
== EXPR_CONSTANT
)
3335 static const char * decimal
[] = { "COMMA", "POINT", NULL
};
3337 if (!compare_to_allowed_values ("DECIMAL", decimal
, NULL
, NULL
,
3338 dt
->decimal
->value
.character
.string
,
3339 io_kind_name (k
), warn
))
3342 io_constraint (unformatted
,
3343 "the DECIMAL= specifier at %L must be with an "
3344 "explicit format expression", &dt
->decimal
->where
);
3350 if (!gfc_notify_std (GFC_STD_F2003
, "BLANK= at %C "
3351 "not allowed in Fortran 95"))
3354 if (dt
->blank
->expr_type
== EXPR_CONSTANT
)
3356 static const char * blank
[] = { "NULL", "ZERO", NULL
};
3358 if (!compare_to_allowed_values ("BLANK", blank
, NULL
, NULL
,
3359 dt
->blank
->value
.character
.string
,
3360 io_kind_name (k
), warn
))
3363 io_constraint (unformatted
,
3364 "the BLANK= specifier at %L must be with an "
3365 "explicit format expression", &dt
->blank
->where
);
3371 if (!gfc_notify_std (GFC_STD_F2003
, "PAD= at %C "
3372 "not allowed in Fortran 95"))
3375 if (dt
->pad
->expr_type
== EXPR_CONSTANT
)
3377 static const char * pad
[] = { "YES", "NO", NULL
};
3379 if (!compare_to_allowed_values ("PAD", pad
, NULL
, NULL
,
3380 dt
->pad
->value
.character
.string
,
3381 io_kind_name (k
), warn
))
3384 io_constraint (unformatted
,
3385 "the PAD= specifier at %L must be with an "
3386 "explicit format expression", &dt
->pad
->where
);
3392 if (!gfc_notify_std (GFC_STD_F2003
, "ROUND= at %C "
3393 "not allowed in Fortran 95"))
3396 if (dt
->round
->expr_type
== EXPR_CONSTANT
)
3398 static const char * round
[] = { "UP", "DOWN", "ZERO", "NEAREST",
3399 "COMPATIBLE", "PROCESSOR_DEFINED",
3402 if (!compare_to_allowed_values ("ROUND", round
, NULL
, NULL
,
3403 dt
->round
->value
.character
.string
,
3404 io_kind_name (k
), warn
))
3411 /* When implemented, change the following to use gfc_notify_std F2003.
3412 if (gfc_notify_std (GFC_STD_F2003, "SIGN= at %C "
3413 "not allowed in Fortran 95") == false)
3414 return MATCH_ERROR; */
3415 if (dt
->sign
->expr_type
== EXPR_CONSTANT
)
3417 static const char * sign
[] = { "PLUS", "SUPPRESS", "PROCESSOR_DEFINED",
3420 if (!compare_to_allowed_values ("SIGN", sign
, NULL
, NULL
,
3421 dt
->sign
->value
.character
.string
,
3422 io_kind_name (k
), warn
))
3425 io_constraint (unformatted
,
3426 "SIGN= specifier at %L must be with an "
3427 "explicit format expression", &dt
->sign
->where
);
3429 io_constraint (k
== M_READ
,
3430 "SIGN= specifier at %L not allowed in a "
3431 "READ statement", &dt
->sign
->where
);
3437 if (!gfc_notify_std (GFC_STD_F2003
, "DELIM= at %C "
3438 "not allowed in Fortran 95"))
3441 if (dt
->delim
->expr_type
== EXPR_CONSTANT
)
3443 static const char *delim
[] = { "APOSTROPHE", "QUOTE", "NONE", NULL
};
3445 if (!compare_to_allowed_values ("DELIM", delim
, NULL
, NULL
,
3446 dt
->delim
->value
.character
.string
,
3447 io_kind_name (k
), warn
))
3450 io_constraint (k
== M_READ
,
3451 "DELIM= specifier at %L not allowed in a "
3452 "READ statement", &dt
->delim
->where
);
3454 io_constraint (dt
->format_label
!= &format_asterisk
3455 && dt
->namelist
== NULL
,
3456 "DELIM= specifier at %L must have FMT=*",
3459 io_constraint (unformatted
&& dt
->namelist
== NULL
,
3460 "DELIM= specifier at %L must be with FMT=* or "
3461 "NML= specifier ", &dt
->delim
->where
);
3467 io_constraint (io_code
&& dt
->namelist
,
3468 "NAMELIST cannot be followed by IO-list at %L",
3471 io_constraint (dt
->format_expr
,
3472 "IO spec-list cannot contain both NAMELIST group name "
3473 "and format specification at %L",
3474 &dt
->format_expr
->where
);
3476 io_constraint (dt
->format_label
,
3477 "IO spec-list cannot contain both NAMELIST group name "
3478 "and format label at %L", spec_end
);
3480 io_constraint (dt
->rec
,
3481 "NAMELIST IO is not allowed with a REC= specifier "
3482 "at %L", &dt
->rec
->where
);
3484 io_constraint (dt
->advance
,
3485 "NAMELIST IO is not allowed with a ADVANCE= specifier "
3486 "at %L", &dt
->advance
->where
);
3491 io_constraint (dt
->end
,
3492 "An END tag is not allowed with a "
3493 "REC= specifier at %L", &dt
->end_where
);
3495 io_constraint (dt
->format_label
== &format_asterisk
,
3496 "FMT=* is not allowed with a REC= specifier "
3499 io_constraint (dt
->pos
,
3500 "POS= is not allowed with REC= specifier "
3501 "at %L", &dt
->pos
->where
);
3506 int not_yes
, not_no
;
3509 io_constraint (dt
->format_label
== &format_asterisk
,
3510 "List directed format(*) is not allowed with a "
3511 "ADVANCE= specifier at %L.", &expr
->where
);
3513 io_constraint (unformatted
,
3514 "the ADVANCE= specifier at %L must appear with an "
3515 "explicit format expression", &expr
->where
);
3517 if (expr
->expr_type
== EXPR_CONSTANT
&& expr
->ts
.type
== BT_CHARACTER
)
3519 const gfc_char_t
*advance
= expr
->value
.character
.string
;
3520 not_no
= gfc_wide_strlen (advance
) != 2
3521 || gfc_wide_strncasecmp (advance
, "no", 2) != 0;
3522 not_yes
= gfc_wide_strlen (advance
) != 3
3523 || gfc_wide_strncasecmp (advance
, "yes", 3) != 0;
3531 io_constraint (not_no
&& not_yes
,
3532 "ADVANCE= specifier at %L must have value = "
3533 "YES or NO.", &expr
->where
);
3535 io_constraint (dt
->size
&& not_no
&& k
== M_READ
,
3536 "SIZE tag at %L requires an ADVANCE = %<NO%>",
3539 io_constraint (dt
->eor
&& not_no
&& k
== M_READ
,
3540 "EOR tag at %L requires an ADVANCE = %<NO%>",
3544 expr
= dt
->format_expr
;
3545 if (!gfc_simplify_expr (expr
, 0)
3546 || !check_format_string (expr
, k
== M_READ
))
3551 #undef io_constraint
3554 /* Match a READ, WRITE or PRINT statement. */
3557 match_io (io_kind k
)
3559 char name
[GFC_MAX_SYMBOL_LEN
+ 1];
3568 where
= gfc_current_locus
;
3570 current_dt
= dt
= XCNEW (gfc_dt
);
3571 m
= gfc_match_char ('(');
3574 where
= gfc_current_locus
;
3577 else if (k
== M_PRINT
)
3579 /* Treat the non-standard case of PRINT namelist. */
3580 if ((gfc_current_form
== FORM_FIXED
|| gfc_peek_ascii_char () == ' ')
3581 && gfc_match_name (name
) == MATCH_YES
)
3583 gfc_find_symbol (name
, NULL
, 1, &sym
);
3584 if (sym
&& sym
->attr
.flavor
== FL_NAMELIST
)
3586 if (!gfc_notify_std (GFC_STD_GNU
, "PRINT namelist at "
3587 "%C is an extension"))
3593 dt
->io_unit
= default_unit (k
);
3598 gfc_current_locus
= where
;
3602 if (gfc_current_form
== FORM_FREE
)
3604 char c
= gfc_peek_ascii_char ();
3605 if (c
!= ' ' && c
!= '*' && c
!= '\'' && c
!= '"')
3612 m
= match_dt_format (dt
);
3613 if (m
== MATCH_ERROR
)
3619 dt
->io_unit
= default_unit (k
);
3624 /* Before issuing an error for a malformed 'print (1,*)' type of
3625 error, check for a default-char-expr of the form ('(I0)'). */
3626 if (k
== M_PRINT
&& m
== MATCH_YES
)
3628 /* Reset current locus to get the initial '(' in an expression. */
3629 gfc_current_locus
= where
;
3630 dt
->format_expr
= NULL
;
3631 m
= match_dt_format (dt
);
3633 if (m
== MATCH_ERROR
)
3635 if (m
== MATCH_NO
|| dt
->format_expr
== NULL
)
3639 dt
->io_unit
= default_unit (k
);
3644 /* Match a control list */
3645 if (match_dt_element (k
, dt
) == MATCH_YES
)
3647 if (match_dt_unit (k
, dt
) != MATCH_YES
)
3650 if (gfc_match_char (')') == MATCH_YES
)
3652 if (gfc_match_char (',') != MATCH_YES
)
3655 m
= match_dt_element (k
, dt
);
3658 if (m
== MATCH_ERROR
)
3661 m
= match_dt_format (dt
);
3664 if (m
== MATCH_ERROR
)
3667 where
= gfc_current_locus
;
3669 m
= gfc_match_name (name
);
3672 gfc_find_symbol (name
, NULL
, 1, &sym
);
3673 if (sym
&& sym
->attr
.flavor
== FL_NAMELIST
)
3676 if (k
== M_READ
&& check_namelist (sym
))
3685 gfc_current_locus
= where
;
3687 goto loop
; /* No matches, try regular elements */
3690 if (gfc_match_char (')') == MATCH_YES
)
3692 if (gfc_match_char (',') != MATCH_YES
)
3698 m
= match_dt_element (k
, dt
);
3701 if (m
== MATCH_ERROR
)
3704 if (gfc_match_char (')') == MATCH_YES
)
3706 if (gfc_match_char (',') != MATCH_YES
)
3712 /* Used in check_io_constraints, where no locus is available. */
3713 spec_end
= gfc_current_locus
;
3715 /* Save the IO kind for later use. */
3716 dt
->dt_io_kind
= gfc_get_iokind_expr (&gfc_current_locus
, k
);
3718 /* Optional leading comma (non-standard). We use a gfc_expr structure here
3719 to save the locus. This is used later when resolving transfer statements
3720 that might have a format expression without unit number. */
3721 if (!comma_flag
&& gfc_match_char (',') == MATCH_YES
)
3722 dt
->extra_comma
= dt
->dt_io_kind
;
3725 if (gfc_match_eos () != MATCH_YES
)
3727 if (comma_flag
&& gfc_match_char (',') != MATCH_YES
)
3729 gfc_error ("Expected comma in I/O list at %C");
3734 m
= match_io_list (k
, &io_code
);
3735 if (m
== MATCH_ERROR
)
3741 /* A full IO statement has been matched. Check the constraints. spec_end is
3742 supplied for cases where no locus is supplied. */
3743 m
= check_io_constraints (k
, dt
, io_code
, &spec_end
);
3745 if (m
== MATCH_ERROR
)
3748 new_st
.op
= (k
== M_READ
) ? EXEC_READ
: EXEC_WRITE
;
3750 new_st
.block
= gfc_get_code (new_st
.op
);
3751 new_st
.block
->next
= io_code
;
3753 terminate_io (io_code
);
3758 gfc_error ("Syntax error in %s statement at %C", io_kind_name (k
));
3768 gfc_match_read (void)
3770 return match_io (M_READ
);
3775 gfc_match_write (void)
3777 return match_io (M_WRITE
);
3782 gfc_match_print (void)
3786 m
= match_io (M_PRINT
);
3790 if (gfc_pure (NULL
))
3792 gfc_error ("PRINT statement at %C not allowed within PURE procedure");
3796 gfc_unset_implicit_pure (NULL
);
3802 /* Free a gfc_inquire structure. */
3805 gfc_free_inquire (gfc_inquire
*inquire
)
3808 if (inquire
== NULL
)
3811 gfc_free_expr (inquire
->unit
);
3812 gfc_free_expr (inquire
->file
);
3813 gfc_free_expr (inquire
->iomsg
);
3814 gfc_free_expr (inquire
->iostat
);
3815 gfc_free_expr (inquire
->exist
);
3816 gfc_free_expr (inquire
->opened
);
3817 gfc_free_expr (inquire
->number
);
3818 gfc_free_expr (inquire
->named
);
3819 gfc_free_expr (inquire
->name
);
3820 gfc_free_expr (inquire
->access
);
3821 gfc_free_expr (inquire
->sequential
);
3822 gfc_free_expr (inquire
->direct
);
3823 gfc_free_expr (inquire
->form
);
3824 gfc_free_expr (inquire
->formatted
);
3825 gfc_free_expr (inquire
->unformatted
);
3826 gfc_free_expr (inquire
->recl
);
3827 gfc_free_expr (inquire
->nextrec
);
3828 gfc_free_expr (inquire
->blank
);
3829 gfc_free_expr (inquire
->position
);
3830 gfc_free_expr (inquire
->action
);
3831 gfc_free_expr (inquire
->read
);
3832 gfc_free_expr (inquire
->write
);
3833 gfc_free_expr (inquire
->readwrite
);
3834 gfc_free_expr (inquire
->delim
);
3835 gfc_free_expr (inquire
->encoding
);
3836 gfc_free_expr (inquire
->pad
);
3837 gfc_free_expr (inquire
->iolength
);
3838 gfc_free_expr (inquire
->convert
);
3839 gfc_free_expr (inquire
->strm_pos
);
3840 gfc_free_expr (inquire
->asynchronous
);
3841 gfc_free_expr (inquire
->decimal
);
3842 gfc_free_expr (inquire
->pending
);
3843 gfc_free_expr (inquire
->id
);
3844 gfc_free_expr (inquire
->sign
);
3845 gfc_free_expr (inquire
->size
);
3846 gfc_free_expr (inquire
->round
);
3851 /* Match an element of an INQUIRE statement. */
3853 #define RETM if (m != MATCH_NO) return m;
3856 match_inquire_element (gfc_inquire
*inquire
)
3860 m
= match_etag (&tag_unit
, &inquire
->unit
);
3861 RETM m
= match_etag (&tag_file
, &inquire
->file
);
3862 RETM m
= match_ltag (&tag_err
, &inquire
->err
);
3863 RETM m
= match_out_tag (&tag_iomsg
, &inquire
->iomsg
);
3864 RETM m
= match_out_tag (&tag_iostat
, &inquire
->iostat
);
3865 RETM m
= match_vtag (&tag_exist
, &inquire
->exist
);
3866 RETM m
= match_vtag (&tag_opened
, &inquire
->opened
);
3867 RETM m
= match_vtag (&tag_named
, &inquire
->named
);
3868 RETM m
= match_vtag (&tag_name
, &inquire
->name
);
3869 RETM m
= match_out_tag (&tag_number
, &inquire
->number
);
3870 RETM m
= match_vtag (&tag_s_access
, &inquire
->access
);
3871 RETM m
= match_vtag (&tag_sequential
, &inquire
->sequential
);
3872 RETM m
= match_vtag (&tag_direct
, &inquire
->direct
);
3873 RETM m
= match_vtag (&tag_s_form
, &inquire
->form
);
3874 RETM m
= match_vtag (&tag_formatted
, &inquire
->formatted
);
3875 RETM m
= match_vtag (&tag_unformatted
, &inquire
->unformatted
);
3876 RETM m
= match_out_tag (&tag_s_recl
, &inquire
->recl
);
3877 RETM m
= match_out_tag (&tag_nextrec
, &inquire
->nextrec
);
3878 RETM m
= match_vtag (&tag_s_blank
, &inquire
->blank
);
3879 RETM m
= match_vtag (&tag_s_position
, &inquire
->position
);
3880 RETM m
= match_vtag (&tag_s_action
, &inquire
->action
);
3881 RETM m
= match_vtag (&tag_read
, &inquire
->read
);
3882 RETM m
= match_vtag (&tag_write
, &inquire
->write
);
3883 RETM m
= match_vtag (&tag_readwrite
, &inquire
->readwrite
);
3884 RETM m
= match_vtag (&tag_s_async
, &inquire
->asynchronous
);
3885 RETM m
= match_vtag (&tag_s_delim
, &inquire
->delim
);
3886 RETM m
= match_vtag (&tag_s_decimal
, &inquire
->decimal
);
3887 RETM m
= match_out_tag (&tag_size
, &inquire
->size
);
3888 RETM m
= match_vtag (&tag_s_encoding
, &inquire
->encoding
);
3889 RETM m
= match_vtag (&tag_s_round
, &inquire
->round
);
3890 RETM m
= match_vtag (&tag_s_sign
, &inquire
->sign
);
3891 RETM m
= match_vtag (&tag_s_pad
, &inquire
->pad
);
3892 RETM m
= match_out_tag (&tag_iolength
, &inquire
->iolength
);
3893 RETM m
= match_vtag (&tag_convert
, &inquire
->convert
);
3894 RETM m
= match_out_tag (&tag_strm_out
, &inquire
->strm_pos
);
3895 RETM m
= match_vtag (&tag_pending
, &inquire
->pending
);
3896 RETM m
= match_vtag (&tag_id
, &inquire
->id
);
3897 RETM m
= match_vtag (&tag_s_iqstream
, &inquire
->iqstream
);
3898 RETM
return MATCH_NO
;
3905 gfc_match_inquire (void)
3907 gfc_inquire
*inquire
;
3912 m
= gfc_match_char ('(');
3916 inquire
= XCNEW (gfc_inquire
);
3918 loc
= gfc_current_locus
;
3920 m
= match_inquire_element (inquire
);
3921 if (m
== MATCH_ERROR
)
3925 m
= gfc_match_expr (&inquire
->unit
);
3926 if (m
== MATCH_ERROR
)
3932 /* See if we have the IOLENGTH form of the inquire statement. */
3933 if (inquire
->iolength
!= NULL
)
3935 if (gfc_match_char (')') != MATCH_YES
)
3938 m
= match_io_list (M_INQUIRE
, &code
);
3939 if (m
== MATCH_ERROR
)
3944 new_st
.op
= EXEC_IOLENGTH
;
3945 new_st
.expr1
= inquire
->iolength
;
3946 new_st
.ext
.inquire
= inquire
;
3948 if (gfc_pure (NULL
))
3950 gfc_free_statements (code
);
3951 gfc_error ("INQUIRE statement not allowed in PURE procedure at %C");
3955 gfc_unset_implicit_pure (NULL
);
3957 new_st
.block
= gfc_get_code (EXEC_IOLENGTH
);
3958 terminate_io (code
);
3959 new_st
.block
->next
= code
;
3963 /* At this point, we have the non-IOLENGTH inquire statement. */
3966 if (gfc_match_char (')') == MATCH_YES
)
3968 if (gfc_match_char (',') != MATCH_YES
)
3971 m
= match_inquire_element (inquire
);
3972 if (m
== MATCH_ERROR
)
3977 if (inquire
->iolength
!= NULL
)
3979 gfc_error ("IOLENGTH tag invalid in INQUIRE statement at %C");
3984 if (gfc_match_eos () != MATCH_YES
)
3987 if (inquire
->unit
!= NULL
&& inquire
->file
!= NULL
)
3989 gfc_error ("INQUIRE statement at %L cannot contain both FILE and "
3990 "UNIT specifiers", &loc
);
3994 if (inquire
->unit
== NULL
&& inquire
->file
== NULL
)
3996 gfc_error ("INQUIRE statement at %L requires either FILE or "
3997 "UNIT specifier", &loc
);
4001 if (inquire
->unit
!= NULL
&& inquire
->unit
->expr_type
== EXPR_CONSTANT
4002 && inquire
->unit
->ts
.type
== BT_INTEGER
4003 && mpz_get_si (inquire
->unit
->value
.integer
) == GFC_INTERNAL_UNIT
)
4005 gfc_error ("UNIT number in INQUIRE statement at %L can not be -1", &loc
);
4009 if (gfc_pure (NULL
))
4011 gfc_error ("INQUIRE statement not allowed in PURE procedure at %C");
4015 gfc_unset_implicit_pure (NULL
);
4017 if (inquire
->id
!= NULL
&& inquire
->pending
== NULL
)
4019 gfc_error ("INQUIRE statement at %L requires a PENDING= specifier with "
4020 "the ID= specifier", &loc
);
4024 new_st
.op
= EXEC_INQUIRE
;
4025 new_st
.ext
.inquire
= inquire
;
4029 gfc_syntax_error (ST_INQUIRE
);
4032 gfc_free_inquire (inquire
);
4037 /* Resolve everything in a gfc_inquire structure. */
4040 gfc_resolve_inquire (gfc_inquire
*inquire
)
4042 RESOLVE_TAG (&tag_unit
, inquire
->unit
);
4043 RESOLVE_TAG (&tag_file
, inquire
->file
);
4044 RESOLVE_TAG (&tag_id
, inquire
->id
);
4046 /* For INQUIRE, all tags except FILE, ID and UNIT are variable definition
4047 contexts. Thus, use an extended RESOLVE_TAG macro for that. */
4048 #define INQUIRE_RESOLVE_TAG(tag, expr) \
4049 RESOLVE_TAG (tag, expr); \
4053 sprintf (context, _("%s tag with INQUIRE"), (tag)->name); \
4054 if (gfc_check_vardef_context ((expr), false, false, false, \
4055 context) == false) \
4058 INQUIRE_RESOLVE_TAG (&tag_iomsg
, inquire
->iomsg
);
4059 INQUIRE_RESOLVE_TAG (&tag_iostat
, inquire
->iostat
);
4060 INQUIRE_RESOLVE_TAG (&tag_exist
, inquire
->exist
);
4061 INQUIRE_RESOLVE_TAG (&tag_opened
, inquire
->opened
);
4062 INQUIRE_RESOLVE_TAG (&tag_number
, inquire
->number
);
4063 INQUIRE_RESOLVE_TAG (&tag_named
, inquire
->named
);
4064 INQUIRE_RESOLVE_TAG (&tag_name
, inquire
->name
);
4065 INQUIRE_RESOLVE_TAG (&tag_s_access
, inquire
->access
);
4066 INQUIRE_RESOLVE_TAG (&tag_sequential
, inquire
->sequential
);
4067 INQUIRE_RESOLVE_TAG (&tag_direct
, inquire
->direct
);
4068 INQUIRE_RESOLVE_TAG (&tag_s_form
, inquire
->form
);
4069 INQUIRE_RESOLVE_TAG (&tag_formatted
, inquire
->formatted
);
4070 INQUIRE_RESOLVE_TAG (&tag_unformatted
, inquire
->unformatted
);
4071 INQUIRE_RESOLVE_TAG (&tag_s_recl
, inquire
->recl
);
4072 INQUIRE_RESOLVE_TAG (&tag_nextrec
, inquire
->nextrec
);
4073 INQUIRE_RESOLVE_TAG (&tag_s_blank
, inquire
->blank
);
4074 INQUIRE_RESOLVE_TAG (&tag_s_position
, inquire
->position
);
4075 INQUIRE_RESOLVE_TAG (&tag_s_action
, inquire
->action
);
4076 INQUIRE_RESOLVE_TAG (&tag_read
, inquire
->read
);
4077 INQUIRE_RESOLVE_TAG (&tag_write
, inquire
->write
);
4078 INQUIRE_RESOLVE_TAG (&tag_readwrite
, inquire
->readwrite
);
4079 INQUIRE_RESOLVE_TAG (&tag_s_delim
, inquire
->delim
);
4080 INQUIRE_RESOLVE_TAG (&tag_s_pad
, inquire
->pad
);
4081 INQUIRE_RESOLVE_TAG (&tag_s_encoding
, inquire
->encoding
);
4082 INQUIRE_RESOLVE_TAG (&tag_s_round
, inquire
->round
);
4083 INQUIRE_RESOLVE_TAG (&tag_iolength
, inquire
->iolength
);
4084 INQUIRE_RESOLVE_TAG (&tag_convert
, inquire
->convert
);
4085 INQUIRE_RESOLVE_TAG (&tag_strm_out
, inquire
->strm_pos
);
4086 INQUIRE_RESOLVE_TAG (&tag_s_async
, inquire
->asynchronous
);
4087 INQUIRE_RESOLVE_TAG (&tag_s_sign
, inquire
->sign
);
4088 INQUIRE_RESOLVE_TAG (&tag_s_round
, inquire
->round
);
4089 INQUIRE_RESOLVE_TAG (&tag_pending
, inquire
->pending
);
4090 INQUIRE_RESOLVE_TAG (&tag_size
, inquire
->size
);
4091 INQUIRE_RESOLVE_TAG (&tag_s_decimal
, inquire
->decimal
);
4092 INQUIRE_RESOLVE_TAG (&tag_s_iqstream
, inquire
->iqstream
);
4093 #undef INQUIRE_RESOLVE_TAG
4095 if (!gfc_reference_st_label (inquire
->err
, ST_LABEL_TARGET
))
4103 gfc_free_wait (gfc_wait
*wait
)
4108 gfc_free_expr (wait
->unit
);
4109 gfc_free_expr (wait
->iostat
);
4110 gfc_free_expr (wait
->iomsg
);
4111 gfc_free_expr (wait
->id
);
4117 gfc_resolve_wait (gfc_wait
*wait
)
4119 RESOLVE_TAG (&tag_unit
, wait
->unit
);
4120 RESOLVE_TAG (&tag_iomsg
, wait
->iomsg
);
4121 RESOLVE_TAG (&tag_iostat
, wait
->iostat
);
4122 RESOLVE_TAG (&tag_id
, wait
->id
);
4124 if (!gfc_reference_st_label (wait
->err
, ST_LABEL_TARGET
))
4127 if (!gfc_reference_st_label (wait
->end
, ST_LABEL_TARGET
))
4133 /* Match an element of a WAIT statement. */
4135 #define RETM if (m != MATCH_NO) return m;
4138 match_wait_element (gfc_wait
*wait
)
4142 m
= match_etag (&tag_unit
, &wait
->unit
);
4143 RETM m
= match_ltag (&tag_err
, &wait
->err
);
4144 RETM m
= match_ltag (&tag_end
, &wait
->eor
);
4145 RETM m
= match_ltag (&tag_eor
, &wait
->end
);
4146 RETM m
= match_out_tag (&tag_iomsg
, &wait
->iomsg
);
4147 RETM m
= match_out_tag (&tag_iostat
, &wait
->iostat
);
4148 RETM m
= match_etag (&tag_id
, &wait
->id
);
4149 RETM
return MATCH_NO
;
4156 gfc_match_wait (void)
4161 m
= gfc_match_char ('(');
4165 wait
= XCNEW (gfc_wait
);
4167 m
= match_wait_element (wait
);
4168 if (m
== MATCH_ERROR
)
4172 m
= gfc_match_expr (&wait
->unit
);
4173 if (m
== MATCH_ERROR
)
4181 if (gfc_match_char (')') == MATCH_YES
)
4183 if (gfc_match_char (',') != MATCH_YES
)
4186 m
= match_wait_element (wait
);
4187 if (m
== MATCH_ERROR
)
4193 if (!gfc_notify_std (GFC_STD_F2003
, "WAIT at %C "
4194 "not allowed in Fortran 95"))
4197 if (gfc_pure (NULL
))
4199 gfc_error ("WAIT statement not allowed in PURE procedure at %C");
4203 gfc_unset_implicit_pure (NULL
);
4205 new_st
.op
= EXEC_WAIT
;
4206 new_st
.ext
.wait
= wait
;
4211 gfc_syntax_error (ST_WAIT
);
4214 gfc_free_wait (wait
);