1 /* Deal with I/O statements & related stuff.
2 Copyright (C) 2000-2017 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
,
31 0, {NULL
, NULL
}, NULL
};
35 const char *name
, *spec
, *value
;
41 tag_readonly
= {"READONLY", " readonly", NULL
, BT_UNKNOWN
},
42 tag_shared
= {"SHARE", " shared", NULL
, BT_UNKNOWN
},
43 tag_noshared
= {"SHARE", " noshared", NULL
, BT_UNKNOWN
},
44 tag_e_share
= {"SHARE", " share =", " %e", BT_CHARACTER
},
45 tag_v_share
= {"SHARE", " share =", " %v", BT_CHARACTER
},
46 tag_cc
= {"CARRIAGECONTROL", " carriagecontrol =", " %e",
48 tag_v_cc
= {"CARRIAGECONTROL", " carriagecontrol =", " %v",
50 tag_file
= {"FILE", " file =", " %e", BT_CHARACTER
},
51 tag_status
= {"STATUS", " status =", " %e", BT_CHARACTER
},
52 tag_e_access
= {"ACCESS", " access =", " %e", BT_CHARACTER
},
53 tag_e_form
= {"FORM", " form =", " %e", BT_CHARACTER
},
54 tag_e_recl
= {"RECL", " recl =", " %e", BT_INTEGER
},
55 tag_e_blank
= {"BLANK", " blank =", " %e", BT_CHARACTER
},
56 tag_e_position
= {"POSITION", " position =", " %e", BT_CHARACTER
},
57 tag_e_action
= {"ACTION", " action =", " %e", BT_CHARACTER
},
58 tag_e_delim
= {"DELIM", " delim =", " %e", BT_CHARACTER
},
59 tag_e_pad
= {"PAD", " pad =", " %e", BT_CHARACTER
},
60 tag_e_decimal
= {"DECIMAL", " decimal =", " %e", BT_CHARACTER
},
61 tag_e_encoding
= {"ENCODING", " encoding =", " %e", BT_CHARACTER
},
62 tag_e_async
= {"ASYNCHRONOUS", " asynchronous =", " %e", BT_CHARACTER
},
63 tag_e_round
= {"ROUND", " round =", " %e", BT_CHARACTER
},
64 tag_e_sign
= {"SIGN", " sign =", " %e", BT_CHARACTER
},
65 tag_unit
= {"UNIT", " unit =", " %e", BT_INTEGER
},
66 tag_advance
= {"ADVANCE", " advance =", " %e", BT_CHARACTER
},
67 tag_rec
= {"REC", " rec =", " %e", BT_INTEGER
},
68 tag_spos
= {"POSITION", " pos =", " %e", BT_INTEGER
},
69 tag_format
= {"FORMAT", NULL
, NULL
, BT_CHARACTER
},
70 tag_iomsg
= {"IOMSG", " iomsg =", " %e", BT_CHARACTER
},
71 tag_iostat
= {"IOSTAT", " iostat =", " %v", BT_INTEGER
},
72 tag_size
= {"SIZE", " size =", " %v", BT_INTEGER
},
73 tag_exist
= {"EXIST", " exist =", " %v", BT_LOGICAL
},
74 tag_opened
= {"OPENED", " opened =", " %v", BT_LOGICAL
},
75 tag_named
= {"NAMED", " named =", " %v", BT_LOGICAL
},
76 tag_name
= {"NAME", " name =", " %v", BT_CHARACTER
},
77 tag_number
= {"NUMBER", " number =", " %v", BT_INTEGER
},
78 tag_s_access
= {"ACCESS", " access =", " %v", BT_CHARACTER
},
79 tag_sequential
= {"SEQUENTIAL", " sequential =", " %v", BT_CHARACTER
},
80 tag_direct
= {"DIRECT", " direct =", " %v", BT_CHARACTER
},
81 tag_s_form
= {"FORM", " form =", " %v", BT_CHARACTER
},
82 tag_formatted
= {"FORMATTED", " formatted =", " %v", BT_CHARACTER
},
83 tag_unformatted
= {"UNFORMATTED", " unformatted =", " %v", BT_CHARACTER
},
84 tag_s_recl
= {"RECL", " recl =", " %v", BT_INTEGER
},
85 tag_nextrec
= {"NEXTREC", " nextrec =", " %v", BT_INTEGER
},
86 tag_s_blank
= {"BLANK", " blank =", " %v", BT_CHARACTER
},
87 tag_s_position
= {"POSITION", " position =", " %v", BT_CHARACTER
},
88 tag_s_action
= {"ACTION", " action =", " %v", BT_CHARACTER
},
89 tag_read
= {"READ", " read =", " %v", BT_CHARACTER
},
90 tag_write
= {"WRITE", " write =", " %v", BT_CHARACTER
},
91 tag_readwrite
= {"READWRITE", " readwrite =", " %v", BT_CHARACTER
},
92 tag_s_delim
= {"DELIM", " delim =", " %v", BT_CHARACTER
},
93 tag_s_pad
= {"PAD", " pad =", " %v", BT_CHARACTER
},
94 tag_s_decimal
= {"DECIMAL", " decimal =", " %v", BT_CHARACTER
},
95 tag_s_encoding
= {"ENCODING", " encoding =", " %v", BT_CHARACTER
},
96 tag_s_async
= {"ASYNCHRONOUS", " asynchronous =", " %v", BT_CHARACTER
},
97 tag_s_round
= {"ROUND", " round =", " %v", BT_CHARACTER
},
98 tag_s_sign
= {"SIGN", " sign =", " %v", BT_CHARACTER
},
99 tag_iolength
= {"IOLENGTH", " iolength =", " %v", BT_INTEGER
},
100 tag_convert
= {"CONVERT", " convert =", " %e", BT_CHARACTER
},
101 tag_strm_out
= {"POS", " pos =", " %v", BT_INTEGER
},
102 tag_err
= {"ERR", " err =", " %l", BT_UNKNOWN
},
103 tag_end
= {"END", " end =", " %l", BT_UNKNOWN
},
104 tag_eor
= {"EOR", " eor =", " %l", BT_UNKNOWN
},
105 tag_id
= {"ID", " id =", " %v", BT_INTEGER
},
106 tag_pending
= {"PENDING", " pending =", " %v", BT_LOGICAL
},
107 tag_newunit
= {"NEWUNIT", " newunit =", " %v", BT_INTEGER
},
108 tag_s_iqstream
= {"STREAM", " stream =", " %v", BT_CHARACTER
};
110 static gfc_dt
*current_dt
;
112 #define RESOLVE_TAG(x, y) if (!resolve_tag (x, y)) return false;
115 /**************** Fortran 95 FORMAT parser *****************/
117 /* FORMAT tokens returned by format_lex(). */
120 FMT_NONE
, FMT_UNKNOWN
, FMT_SIGNED_INT
, FMT_ZERO
, FMT_POSINT
, FMT_PERIOD
,
121 FMT_COMMA
, FMT_COLON
, FMT_SLASH
, FMT_DOLLAR
, FMT_LPAREN
,
122 FMT_RPAREN
, FMT_X
, FMT_SIGN
, FMT_BLANK
, FMT_CHAR
, FMT_P
, FMT_IBOZ
, FMT_F
,
123 FMT_E
, FMT_EN
, FMT_ES
, FMT_G
, FMT_L
, FMT_A
, FMT_D
, FMT_H
, FMT_END
,
124 FMT_ERROR
, FMT_DC
, FMT_DP
, FMT_T
, FMT_TR
, FMT_TL
, FMT_STAR
, FMT_RC
,
125 FMT_RD
, FMT_RN
, FMT_RP
, FMT_RU
, FMT_RZ
, FMT_DT
128 /* Local variables for checking format strings. The saved_token is
129 used to back up by a single format token during the parsing
131 static gfc_char_t
*format_string
;
132 static int format_string_pos
;
133 static int format_length
, use_last_char
;
134 static char error_element
;
135 static locus format_locus
;
137 static format_token saved_token
;
140 { MODE_STRING
, MODE_FORMAT
, MODE_COPY
}
144 /* Return the next character in the format string. */
147 next_char (gfc_instring in_string
)
159 if (mode
== MODE_STRING
)
160 c
= *format_string
++;
163 c
= gfc_next_char_literal (in_string
);
168 if (flag_backslash
&& c
== '\\')
170 locus old_locus
= gfc_current_locus
;
172 if (gfc_match_special_char (&c
) == MATCH_NO
)
173 gfc_current_locus
= old_locus
;
175 if (!(gfc_option
.allow_std
& GFC_STD_GNU
) && !inhibit_warnings
)
176 gfc_warning (0, "Extension: backslash character at %C");
179 if (mode
== MODE_COPY
)
180 *format_string
++ = c
;
182 if (mode
!= MODE_STRING
)
183 format_locus
= gfc_current_locus
;
187 c
= gfc_wide_toupper (c
);
192 /* Back up one character position. Only works once. */
200 /* Eat up the spaces and return a character. */
203 next_char_not_space ()
208 error_element
= c
= next_char (NONSTRING
);
210 gfc_warning (OPT_Wtabs
, "Nonconforming tab character in format at %C");
212 while (gfc_is_whitespace (c
));
216 static int value
= 0;
218 /* Simple lexical analyzer for getting the next token in a FORMAT
229 if (saved_token
!= FMT_NONE
)
232 saved_token
= FMT_NONE
;
236 c
= next_char_not_space ();
246 c
= next_char_not_space ();
257 c
= next_char_not_space ();
259 value
= 10 * value
+ c
- '0';
268 token
= FMT_SIGNED_INT
;
287 c
= next_char_not_space ();
290 value
= 10 * value
+ c
- '0';
298 token
= zflag
? FMT_ZERO
: FMT_POSINT
;
322 c
= next_char_not_space ();
350 c
= next_char_not_space ();
351 if (c
!= 'P' && c
!= 'S')
358 c
= next_char_not_space ();
359 if (c
== 'N' || c
== 'Z')
377 c
= next_char (INSTRING_WARN
);
386 c
= next_char (NONSTRING
);
420 c
= next_char_not_space ();
450 c
= next_char_not_space ();
453 if (!gfc_notify_std (GFC_STD_F2003
, "DP format "
454 "specifier not allowed at %C"))
460 if (!gfc_notify_std (GFC_STD_F2003
, "DC format "
461 "specifier not allowed at %C"))
467 if (!gfc_notify_std (GFC_STD_F2003
, "Fortran 2003: DT format "
468 "specifier not allowed at %C"))
471 c
= next_char_not_space ();
472 if (c
== '\'' || c
== '"')
479 c
= next_char (INSTRING_WARN
);
488 c
= next_char (NONSTRING
);
512 c
= next_char_not_space ();
558 token_to_string (format_token t
)
577 /* Check a format statement. The format string, either from a FORMAT
578 statement or a constant in an I/O statement has already been parsed
579 by itself, and we are checking it for validity. The dual origin
580 means that the warning message is a little less than great. */
583 check_format (bool is_input
)
585 const char *posint_required
= _("Positive width required");
586 const char *nonneg_required
= _("Nonnegative width required");
587 const char *unexpected_element
= _("Unexpected element %qc in format "
589 const char *unexpected_end
= _("Unexpected end of format string");
590 const char *zero_width
= _("Zero width in format descriptor");
592 const char *error
= NULL
;
599 saved_token
= FMT_NONE
;
603 format_string_pos
= 0;
610 error
= _("Missing leading left parenthesis");
618 goto finished
; /* Empty format is legal */
622 /* In this state, the next thing has to be a format item. */
639 error
= _("Left parenthesis required after %<*%>");
664 /* Signed integer can only precede a P format. */
670 error
= _("Expected P edit descriptor");
677 /* P requires a prior number. */
678 error
= _("P descriptor requires leading scale factor");
682 /* X requires a prior number if we're being pedantic. */
683 if (mode
!= MODE_FORMAT
)
684 format_locus
.nextc
+= format_string_pos
;
685 if (!gfc_notify_std (GFC_STD_GNU
, "X descriptor requires leading "
686 "space count at %L", &format_locus
))
714 error
= posint_required
;
726 error
= _("Right parenthesis expected at %C");
732 error
= unexpected_element
;
751 goto extension_optional_comma
;
762 if (!gfc_notify_std (GFC_STD_GNU
, "$ descriptor at %L", &format_locus
))
764 if (t
!= FMT_RPAREN
|| level
> 0)
766 gfc_warning (0, "$ should be the last specifier in format at %L",
768 goto optional_comma_1
;
789 error
= unexpected_end
;
793 error
= unexpected_element
;
798 /* In this state, t must currently be a data descriptor.
799 Deal with things that can/must follow the descriptor. */
810 /* No comma after P allowed only for F, E, EN, ES, D, or G.
815 if (!(gfc_option
.allow_std
& GFC_STD_F2003
) && t
!= FMT_COMMA
816 && t
!= FMT_F
&& t
!= FMT_E
&& t
!= FMT_EN
&& t
!= FMT_ES
817 && t
!= FMT_D
&& t
!= FMT_G
&& t
!= FMT_RPAREN
&& t
!= FMT_SLASH
)
819 error
= _("Comma required after P descriptor");
830 if (t
!= FMT_F
&& t
!= FMT_E
&& t
!= FMT_EN
&& t
!= FMT_ES
&& t
!= FMT_D
831 && t
!= FMT_G
&& t
!= FMT_RPAREN
&& t
!= FMT_SLASH
)
833 error
= _("Comma required after P descriptor");
847 error
= _("Positive width required with T descriptor");
858 if (mode
!= MODE_FORMAT
)
859 format_locus
.nextc
+= format_string_pos
;
862 switch (gfc_notification_std (GFC_STD_GNU
))
865 gfc_warning (0, "Extension: Zero width after L "
866 "descriptor at %L", &format_locus
);
869 gfc_error ("Extension: Zero width after L "
870 "descriptor at %L", &format_locus
);
881 gfc_notify_std (GFC_STD_GNU
, "Missing positive width after "
882 "L descriptor at %L", &format_locus
);
905 if (t
== FMT_G
&& u
== FMT_ZERO
)
912 if (!gfc_notify_std (GFC_STD_F2008
, "%<G0%> in format at %L",
924 error
= posint_required
;
930 error
= _("E specifier not allowed with g0 descriptor");
939 format_locus
.nextc
+= format_string_pos
;
940 gfc_error ("Positive width required in format "
941 "specifier %s at %L", token_to_string (t
),
952 /* Warn if -std=legacy, otherwise error. */
953 format_locus
.nextc
+= format_string_pos
;
954 if (gfc_option
.warn_std
!= 0)
956 gfc_error ("Period required in format "
957 "specifier %s at %L", token_to_string (t
),
963 gfc_warning (0, "Period required in format "
964 "specifier %s at %L", token_to_string (t
),
966 /* If we go to finished, we need to unwind this
967 before the next round. */
968 format_locus
.nextc
-= format_string_pos
;
976 if (u
!= FMT_ZERO
&& u
!= FMT_POSINT
)
978 error
= nonneg_required
;
985 /* Look for optional exponent. */
1000 error
= _("Positive exponent width required");
1011 if (t
!= FMT_ZERO
&& t
!= FMT_POSINT
)
1013 error
= nonneg_required
;
1016 else if (is_input
&& t
== FMT_ZERO
)
1018 error
= posint_required
;
1025 if (t
!= FMT_PERIOD
)
1027 /* Warn if -std=legacy, otherwise error. */
1028 if (gfc_option
.warn_std
!= 0)
1030 error
= _("Period required in format specifier");
1033 if (mode
!= MODE_FORMAT
)
1034 format_locus
.nextc
+= format_string_pos
;
1035 gfc_warning (0, "Period required in format specifier at %L",
1044 if (t
!= FMT_ZERO
&& t
!= FMT_POSINT
)
1046 error
= nonneg_required
;
1053 if (!(gfc_option
.allow_std
& GFC_STD_GNU
) && !inhibit_warnings
)
1055 if (mode
!= MODE_FORMAT
)
1056 format_locus
.nextc
+= format_string_pos
;
1057 gfc_warning (0, "The H format specifier at %L is"
1058 " a Fortran 95 deleted feature", &format_locus
);
1060 if (mode
== MODE_STRING
)
1062 format_string
+= value
;
1063 format_length
-= value
;
1064 format_string_pos
+= repeat
;
1070 next_char (INSTRING_WARN
);
1080 if (t
!= FMT_ZERO
&& t
!= FMT_POSINT
)
1082 error
= nonneg_required
;
1085 else if (is_input
&& t
== FMT_ZERO
)
1087 error
= posint_required
;
1094 if (t
!= FMT_PERIOD
)
1103 if (t
!= FMT_ZERO
&& t
!= FMT_POSINT
)
1105 error
= nonneg_required
;
1113 error
= unexpected_element
;
1118 /* Between a descriptor and what comes next. */
1136 goto optional_comma
;
1139 error
= unexpected_end
;
1143 if (mode
!= MODE_FORMAT
)
1144 format_locus
.nextc
+= format_string_pos
- 1;
1145 if (!gfc_notify_std (GFC_STD_GNU
, "Missing comma at %L", &format_locus
))
1147 /* If we do not actually return a failure, we need to unwind this
1148 before the next round. */
1149 if (mode
!= MODE_FORMAT
)
1150 format_locus
.nextc
-= format_string_pos
;
1155 /* Optional comma is a weird between state where we've just finished
1156 reading a colon, slash, dollar or P descriptor. */
1173 /* Assume that we have another format item. */
1180 extension_optional_comma
:
1181 /* As a GNU extension, permit a missing comma after a string literal. */
1198 goto optional_comma
;
1201 error
= unexpected_end
;
1205 if (mode
!= MODE_FORMAT
)
1206 format_locus
.nextc
+= format_string_pos
;
1207 if (!gfc_notify_std (GFC_STD_GNU
, "Missing comma at %L", &format_locus
))
1209 /* If we do not actually return a failure, we need to unwind this
1210 before the next round. */
1211 if (mode
!= MODE_FORMAT
)
1212 format_locus
.nextc
-= format_string_pos
;
1220 if (mode
!= MODE_FORMAT
)
1221 format_locus
.nextc
+= format_string_pos
;
1222 if (error
== unexpected_element
)
1223 gfc_error (error
, error_element
, &format_locus
);
1225 gfc_error ("%s in format string at %L", error
, &format_locus
);
1234 /* Given an expression node that is a constant string, see if it looks
1235 like a format string. */
1238 check_format_string (gfc_expr
*e
, bool is_input
)
1242 if (!e
|| e
->ts
.type
!= BT_CHARACTER
|| e
->expr_type
!= EXPR_CONSTANT
)
1246 format_string
= e
->value
.character
.string
;
1248 /* More elaborate measures are needed to show where a problem is within a
1249 format string that has been calculated, but that's probably not worth the
1251 format_locus
= e
->where
;
1252 rv
= check_format (is_input
);
1253 /* check for extraneous characters at the end of an otherwise valid format
1254 string, like '(A10,I3)F5'
1255 start at the end and move back to the last character processed,
1257 if (rv
&& e
->value
.character
.length
> format_string_pos
)
1258 for (i
=e
->value
.character
.length
-1;i
>format_string_pos
-1;i
--)
1259 if (e
->value
.character
.string
[i
] != ' ')
1261 format_locus
.nextc
+= format_length
+ 1;
1263 "Extraneous characters in format at %L", &format_locus
);
1270 /************ Fortran I/O statement matchers *************/
1272 /* Match a FORMAT statement. This amounts to actually parsing the
1273 format descriptors in order to correctly locate the end of the
1277 gfc_match_format (void)
1282 if (gfc_current_ns
->proc_name
1283 && gfc_current_ns
->proc_name
->attr
.flavor
== FL_MODULE
)
1285 gfc_error ("Format statement in module main block at %C");
1289 /* Before parsing the rest of a FORMAT statement, check F2008:c1206. */
1290 if ((gfc_current_state () == COMP_FUNCTION
1291 || gfc_current_state () == COMP_SUBROUTINE
)
1292 && gfc_state_stack
->previous
->state
== COMP_INTERFACE
)
1294 gfc_error ("FORMAT statement at %C cannot appear within an INTERFACE");
1298 if (gfc_statement_label
== NULL
)
1300 gfc_error ("Missing format label at %C");
1303 gfc_gobble_whitespace ();
1308 start
= gfc_current_locus
;
1310 if (!check_format (false))
1313 if (gfc_match_eos () != MATCH_YES
)
1315 gfc_syntax_error (ST_FORMAT
);
1319 /* The label doesn't get created until after the statement is done
1320 being matched, so we have to leave the string for later. */
1322 gfc_current_locus
= start
; /* Back to the beginning */
1325 new_st
.op
= EXEC_NOP
;
1327 e
= gfc_get_character_expr (gfc_default_character_kind
, &start
,
1328 NULL
, format_length
);
1329 format_string
= e
->value
.character
.string
;
1330 gfc_statement_label
->format
= e
;
1333 check_format (false); /* Guaranteed to succeed */
1334 gfc_match_eos (); /* Guaranteed to succeed */
1340 /* Check for a CHARACTER variable. The check for scalar is done in
1344 check_char_variable (gfc_expr
*e
)
1346 if (e
->expr_type
!= EXPR_VARIABLE
|| e
->ts
.type
!= BT_CHARACTER
)
1348 gfc_error("IOMSG must be a scalar-default-char-variable at %L", &e
->where
);
1356 is_char_type (const char *name
, gfc_expr
*e
)
1358 gfc_resolve_expr (e
);
1360 if (e
->ts
.type
!= BT_CHARACTER
)
1362 gfc_error ("%s requires a scalar-default-char-expr at %L",
1370 /* Match an expression I/O tag of some sort. */
1373 match_etag (const io_tag
*tag
, gfc_expr
**v
)
1378 m
= gfc_match (tag
->spec
);
1382 m
= gfc_match (tag
->value
, &result
);
1385 gfc_error ("Invalid value for %s specification at %C", tag
->name
);
1391 gfc_error ("Duplicate %s specification at %C", tag
->name
);
1392 gfc_free_expr (result
);
1401 /* Match a variable I/O tag of some sort. */
1404 match_vtag (const io_tag
*tag
, gfc_expr
**v
)
1409 m
= gfc_match (tag
->spec
);
1413 m
= gfc_match (tag
->value
, &result
);
1416 gfc_error ("Invalid value for %s specification at %C", tag
->name
);
1422 gfc_error ("Duplicate %s specification at %C", tag
->name
);
1423 gfc_free_expr (result
);
1427 if (result
->symtree
->n
.sym
->attr
.intent
== INTENT_IN
)
1429 gfc_error ("Variable %s cannot be INTENT(IN) at %C", tag
->name
);
1430 gfc_free_expr (result
);
1434 bool impure
= gfc_impure_variable (result
->symtree
->n
.sym
);
1435 if (impure
&& gfc_pure (NULL
))
1437 gfc_error ("Variable %s cannot be assigned in PURE procedure at %C",
1439 gfc_free_expr (result
);
1444 gfc_unset_implicit_pure (NULL
);
1451 /* Match I/O tags that cause variables to become redefined. */
1454 match_out_tag (const io_tag
*tag
, gfc_expr
**result
)
1458 m
= match_vtag (tag
, result
);
1460 gfc_check_do_variable ((*result
)->symtree
);
1466 /* Match a label I/O tag. */
1469 match_ltag (const io_tag
*tag
, gfc_st_label
** label
)
1475 m
= gfc_match (tag
->spec
);
1479 m
= gfc_match (tag
->value
, label
);
1482 gfc_error ("Invalid value for %s specification at %C", tag
->name
);
1488 gfc_error ("Duplicate %s label specification at %C", tag
->name
);
1492 if (!gfc_reference_st_label (*label
, ST_LABEL_TARGET
))
1499 /* Match a tag using match_etag, but only if -fdec is enabled. */
1501 match_dec_etag (const io_tag
*tag
, gfc_expr
**e
)
1503 match m
= match_etag (tag
, e
);
1504 if (flag_dec
&& m
!= MATCH_NO
)
1506 else if (m
!= MATCH_NO
)
1508 gfc_error ("%s is a DEC extension at %C, re-compile with "
1509 "-fdec to enable", tag
->name
);
1516 /* Match a tag using match_vtag, but only if -fdec is enabled. */
1518 match_dec_vtag (const io_tag
*tag
, gfc_expr
**e
)
1520 match m
= match_vtag(tag
, e
);
1521 if (flag_dec
&& m
!= MATCH_NO
)
1523 else if (m
!= MATCH_NO
)
1525 gfc_error ("%s is a DEC extension at %C, re-compile with "
1526 "-fdec to enable", tag
->name
);
1533 /* Match a DEC I/O flag tag - a tag with no expression such as READONLY. */
1536 match_dec_ftag (const io_tag
*tag
, gfc_open
*o
)
1540 m
= gfc_match (tag
->spec
);
1546 gfc_error ("%s is a DEC extension at %C, re-compile with "
1547 "-fdec to enable", tag
->name
);
1551 /* Just set the READONLY flag, which we use at runtime to avoid delete on
1553 if (tag
== &tag_readonly
)
1559 /* Interpret SHARED as SHARE='DENYNONE' (read lock). */
1560 else if (tag
== &tag_shared
)
1562 if (o
->share
!= NULL
)
1564 gfc_error ("Duplicate %s specification at %C", tag
->name
);
1567 o
->share
= gfc_get_character_expr (gfc_default_character_kind
,
1568 &gfc_current_locus
, "denynone", 8);
1572 /* Interpret NOSHARED as SHARE='DENYRW' (exclusive lock). */
1573 else if (tag
== &tag_noshared
)
1575 if (o
->share
!= NULL
)
1577 gfc_error ("Duplicate %s specification at %C", tag
->name
);
1580 o
->share
= gfc_get_character_expr (gfc_default_character_kind
,
1581 &gfc_current_locus
, "denyrw", 6);
1585 /* We handle all DEC tags above. */
1590 /* Resolution of the FORMAT tag, to be called from resolve_tag. */
1593 resolve_tag_format (const gfc_expr
*e
)
1595 if (e
->expr_type
== EXPR_CONSTANT
1596 && (e
->ts
.type
!= BT_CHARACTER
1597 || e
->ts
.kind
!= gfc_default_character_kind
))
1599 gfc_error ("Constant expression in FORMAT tag at %L must be "
1600 "of type default CHARACTER", &e
->where
);
1604 /* If e's rank is zero and e is not an element of an array, it should be
1605 of integer or character type. The integer variable should be
1608 && (e
->expr_type
!= EXPR_VARIABLE
1609 || e
->symtree
== NULL
1610 || e
->symtree
->n
.sym
->as
== NULL
1611 || e
->symtree
->n
.sym
->as
->rank
== 0))
1613 if ((e
->ts
.type
!= BT_CHARACTER
1614 || e
->ts
.kind
!= gfc_default_character_kind
)
1615 && e
->ts
.type
!= BT_INTEGER
)
1617 gfc_error ("FORMAT tag at %L must be of type default-kind CHARACTER "
1618 "or of INTEGER", &e
->where
);
1621 else if (e
->ts
.type
== BT_INTEGER
&& e
->expr_type
== EXPR_VARIABLE
)
1623 if (!gfc_notify_std (GFC_STD_F95_DEL
, "ASSIGNED variable in "
1624 "FORMAT tag at %L", &e
->where
))
1626 if (e
->symtree
->n
.sym
->attr
.assign
!= 1)
1628 gfc_error ("Variable %qs at %L has not been assigned a "
1629 "format label", e
->symtree
->n
.sym
->name
, &e
->where
);
1633 else if (e
->ts
.type
== BT_INTEGER
)
1635 gfc_error ("Scalar %qs in FORMAT tag at %L is not an ASSIGNED "
1636 "variable", gfc_basic_typename (e
->ts
.type
), &e
->where
);
1643 /* If rank is nonzero and type is not character, we allow it under GFC_STD_LEGACY.
1644 It may be assigned an Hollerith constant. */
1645 if (e
->ts
.type
!= BT_CHARACTER
)
1647 if (!gfc_notify_std (GFC_STD_LEGACY
, "Non-character in FORMAT tag "
1648 "at %L", &e
->where
))
1651 if (e
->rank
== 0 && e
->symtree
->n
.sym
->as
->type
== AS_ASSUMED_SHAPE
)
1653 gfc_error ("Non-character assumed shape array element in FORMAT"
1654 " tag at %L", &e
->where
);
1658 if (e
->rank
== 0 && e
->symtree
->n
.sym
->as
->type
== AS_ASSUMED_SIZE
)
1660 gfc_error ("Non-character assumed size array element in FORMAT"
1661 " tag at %L", &e
->where
);
1665 if (e
->rank
== 0 && e
->symtree
->n
.sym
->attr
.pointer
)
1667 gfc_error ("Non-character pointer array element in FORMAT tag at %L",
1677 /* Do expression resolution and type-checking on an expression tag. */
1680 resolve_tag (const io_tag
*tag
, gfc_expr
*e
)
1685 if (!gfc_resolve_expr (e
))
1688 if (tag
== &tag_format
)
1689 return resolve_tag_format (e
);
1691 if (e
->ts
.type
!= tag
->type
)
1693 gfc_error ("%s tag at %L must be of type %s", tag
->name
,
1694 &e
->where
, gfc_basic_typename (tag
->type
));
1698 if (e
->ts
.type
== BT_CHARACTER
&& e
->ts
.kind
!= gfc_default_character_kind
)
1700 gfc_error ("%s tag at %L must be a character string of default kind",
1701 tag
->name
, &e
->where
);
1707 gfc_error ("%s tag at %L must be scalar", tag
->name
, &e
->where
);
1711 if (tag
== &tag_iomsg
)
1713 if (!gfc_notify_std (GFC_STD_F2003
, "IOMSG tag at %L", &e
->where
))
1717 if ((tag
== &tag_iostat
|| tag
== &tag_size
|| tag
== &tag_iolength
1718 || tag
== &tag_number
|| tag
== &tag_nextrec
|| tag
== &tag_s_recl
)
1719 && e
->ts
.kind
!= gfc_default_integer_kind
)
1721 if (!gfc_notify_std (GFC_STD_F2003
, "Fortran 95 requires default "
1722 "INTEGER in %s tag at %L", tag
->name
, &e
->where
))
1726 if (e
->ts
.kind
!= gfc_default_logical_kind
&&
1727 (tag
== &tag_exist
|| tag
== &tag_named
|| tag
== &tag_opened
1728 || tag
== &tag_pending
))
1730 if (!gfc_notify_std (GFC_STD_F2008
, "Non-default LOGICAL kind "
1731 "in %s tag at %L", tag
->name
, &e
->where
))
1735 if (tag
== &tag_newunit
)
1737 if (!gfc_notify_std (GFC_STD_F2008
, "NEWUNIT specifier at %L",
1742 /* NEWUNIT, IOSTAT, SIZE and IOMSG are variable definition contexts. */
1743 if (tag
== &tag_newunit
|| tag
== &tag_iostat
1744 || tag
== &tag_size
|| tag
== &tag_iomsg
)
1748 sprintf (context
, _("%s tag"), tag
->name
);
1749 if (!gfc_check_vardef_context (e
, false, false, false, context
))
1753 if (tag
== &tag_convert
)
1755 if (!gfc_notify_std (GFC_STD_GNU
, "CONVERT tag at %L", &e
->where
))
1763 /* Match a single tag of an OPEN statement. */
1766 match_open_element (gfc_open
*open
)
1770 m
= match_etag (&tag_e_async
, &open
->asynchronous
);
1771 if (m
== MATCH_YES
&& !is_char_type ("ASYNCHRONOUS", open
->asynchronous
))
1775 m
= match_etag (&tag_unit
, &open
->unit
);
1778 m
= match_etag (&tag_iomsg
, &open
->iomsg
);
1779 if (m
== MATCH_YES
&& !check_char_variable (open
->iomsg
))
1783 m
= match_out_tag (&tag_iostat
, &open
->iostat
);
1786 m
= match_etag (&tag_file
, &open
->file
);
1789 m
= match_etag (&tag_status
, &open
->status
);
1792 m
= match_etag (&tag_e_access
, &open
->access
);
1795 m
= match_etag (&tag_e_form
, &open
->form
);
1798 m
= match_etag (&tag_e_recl
, &open
->recl
);
1801 m
= match_etag (&tag_e_blank
, &open
->blank
);
1804 m
= match_etag (&tag_e_position
, &open
->position
);
1807 m
= match_etag (&tag_e_action
, &open
->action
);
1810 m
= match_etag (&tag_e_delim
, &open
->delim
);
1813 m
= match_etag (&tag_e_pad
, &open
->pad
);
1816 m
= match_etag (&tag_e_decimal
, &open
->decimal
);
1819 m
= match_etag (&tag_e_encoding
, &open
->encoding
);
1822 m
= match_etag (&tag_e_round
, &open
->round
);
1825 m
= match_etag (&tag_e_sign
, &open
->sign
);
1828 m
= match_ltag (&tag_err
, &open
->err
);
1831 m
= match_etag (&tag_convert
, &open
->convert
);
1834 m
= match_out_tag (&tag_newunit
, &open
->newunit
);
1838 /* The following are extensions enabled with -fdec. */
1839 m
= match_dec_etag (&tag_e_share
, &open
->share
);
1842 m
= match_dec_etag (&tag_cc
, &open
->cc
);
1845 m
= match_dec_ftag (&tag_readonly
, open
);
1848 m
= match_dec_ftag (&tag_shared
, open
);
1851 m
= match_dec_ftag (&tag_noshared
, open
);
1859 /* Free the gfc_open structure and all the expressions it contains. */
1862 gfc_free_open (gfc_open
*open
)
1867 gfc_free_expr (open
->unit
);
1868 gfc_free_expr (open
->iomsg
);
1869 gfc_free_expr (open
->iostat
);
1870 gfc_free_expr (open
->file
);
1871 gfc_free_expr (open
->status
);
1872 gfc_free_expr (open
->access
);
1873 gfc_free_expr (open
->form
);
1874 gfc_free_expr (open
->recl
);
1875 gfc_free_expr (open
->blank
);
1876 gfc_free_expr (open
->position
);
1877 gfc_free_expr (open
->action
);
1878 gfc_free_expr (open
->delim
);
1879 gfc_free_expr (open
->pad
);
1880 gfc_free_expr (open
->decimal
);
1881 gfc_free_expr (open
->encoding
);
1882 gfc_free_expr (open
->round
);
1883 gfc_free_expr (open
->sign
);
1884 gfc_free_expr (open
->convert
);
1885 gfc_free_expr (open
->asynchronous
);
1886 gfc_free_expr (open
->newunit
);
1887 gfc_free_expr (open
->share
);
1888 gfc_free_expr (open
->cc
);
1893 /* Resolve everything in a gfc_open structure. */
1896 gfc_resolve_open (gfc_open
*open
)
1899 RESOLVE_TAG (&tag_unit
, open
->unit
);
1900 RESOLVE_TAG (&tag_iomsg
, open
->iomsg
);
1901 RESOLVE_TAG (&tag_iostat
, open
->iostat
);
1902 RESOLVE_TAG (&tag_file
, open
->file
);
1903 RESOLVE_TAG (&tag_status
, open
->status
);
1904 RESOLVE_TAG (&tag_e_access
, open
->access
);
1905 RESOLVE_TAG (&tag_e_form
, open
->form
);
1906 RESOLVE_TAG (&tag_e_recl
, open
->recl
);
1907 RESOLVE_TAG (&tag_e_blank
, open
->blank
);
1908 RESOLVE_TAG (&tag_e_position
, open
->position
);
1909 RESOLVE_TAG (&tag_e_action
, open
->action
);
1910 RESOLVE_TAG (&tag_e_delim
, open
->delim
);
1911 RESOLVE_TAG (&tag_e_pad
, open
->pad
);
1912 RESOLVE_TAG (&tag_e_decimal
, open
->decimal
);
1913 RESOLVE_TAG (&tag_e_encoding
, open
->encoding
);
1914 RESOLVE_TAG (&tag_e_async
, open
->asynchronous
);
1915 RESOLVE_TAG (&tag_e_round
, open
->round
);
1916 RESOLVE_TAG (&tag_e_sign
, open
->sign
);
1917 RESOLVE_TAG (&tag_convert
, open
->convert
);
1918 RESOLVE_TAG (&tag_newunit
, open
->newunit
);
1919 RESOLVE_TAG (&tag_e_share
, open
->share
);
1920 RESOLVE_TAG (&tag_cc
, open
->cc
);
1922 if (!gfc_reference_st_label (open
->err
, ST_LABEL_TARGET
))
1929 /* Check if a given value for a SPECIFIER is either in the list of values
1930 allowed in F95 or F2003, issuing an error message and returning a zero
1931 value if it is not allowed. */
1934 compare_to_allowed_values (const char *specifier
, const char *allowed
[],
1935 const char *allowed_f2003
[],
1936 const char *allowed_gnu
[], gfc_char_t
*value
,
1937 const char *statement
, bool warn
)
1942 len
= gfc_wide_strlen (value
);
1945 for (len
--; len
> 0; len
--)
1946 if (value
[len
] != ' ')
1951 for (i
= 0; allowed
[i
]; i
++)
1952 if (len
== strlen (allowed
[i
])
1953 && gfc_wide_strncasecmp (value
, allowed
[i
], strlen (allowed
[i
])) == 0)
1956 for (i
= 0; allowed_f2003
&& allowed_f2003
[i
]; i
++)
1957 if (len
== strlen (allowed_f2003
[i
])
1958 && gfc_wide_strncasecmp (value
, allowed_f2003
[i
],
1959 strlen (allowed_f2003
[i
])) == 0)
1961 notification n
= gfc_notification_std (GFC_STD_F2003
);
1963 if (n
== WARNING
|| (warn
&& n
== ERROR
))
1965 gfc_warning (0, "Fortran 2003: %s specifier in %s statement at %C "
1966 "has value %qs", specifier
, statement
,
1973 gfc_notify_std (GFC_STD_F2003
, "%s specifier in "
1974 "%s statement at %C has value %qs", specifier
,
1975 statement
, allowed_f2003
[i
]);
1983 for (i
= 0; allowed_gnu
&& allowed_gnu
[i
]; i
++)
1984 if (len
== strlen (allowed_gnu
[i
])
1985 && gfc_wide_strncasecmp (value
, allowed_gnu
[i
],
1986 strlen (allowed_gnu
[i
])) == 0)
1988 notification n
= gfc_notification_std (GFC_STD_GNU
);
1990 if (n
== WARNING
|| (warn
&& n
== ERROR
))
1992 gfc_warning (0, "Extension: %s specifier in %s statement at %C "
1993 "has value %qs", specifier
, statement
,
2000 gfc_notify_std (GFC_STD_GNU
, "%s specifier in "
2001 "%s statement at %C has value %qs", specifier
,
2002 statement
, allowed_gnu
[i
]);
2012 char *s
= gfc_widechar_to_char (value
, -1);
2014 "%s specifier in %s statement at %C has invalid value %qs",
2015 specifier
, statement
, s
);
2021 char *s
= gfc_widechar_to_char (value
, -1);
2022 gfc_error ("%s specifier in %s statement at %C has invalid value %qs",
2023 specifier
, statement
, s
);
2030 /* Match an OPEN statement. */
2033 gfc_match_open (void)
2039 m
= gfc_match_char ('(');
2043 open
= XCNEW (gfc_open
);
2045 m
= match_open_element (open
);
2047 if (m
== MATCH_ERROR
)
2051 m
= gfc_match_expr (&open
->unit
);
2052 if (m
== MATCH_ERROR
)
2058 if (gfc_match_char (')') == MATCH_YES
)
2060 if (gfc_match_char (',') != MATCH_YES
)
2063 m
= match_open_element (open
);
2064 if (m
== MATCH_ERROR
)
2070 if (gfc_match_eos () == MATCH_NO
)
2073 if (gfc_pure (NULL
))
2075 gfc_error ("OPEN statement not allowed in PURE procedure at %C");
2079 gfc_unset_implicit_pure (NULL
);
2081 warn
= (open
->err
|| open
->iostat
) ? true : false;
2083 /* Checks on NEWUNIT specifier. */
2088 gfc_error ("UNIT specifier not allowed with NEWUNIT at %C");
2092 if (!open
->file
&& open
->status
)
2094 if (open
->status
->expr_type
== EXPR_CONSTANT
2095 && gfc_wide_strncasecmp (open
->status
->value
.character
.string
,
2098 gfc_error ("NEWUNIT specifier must have FILE= "
2099 "or STATUS='scratch' at %C");
2104 else if (!open
->unit
)
2106 gfc_error ("OPEN statement at %C must have UNIT or NEWUNIT specified");
2110 /* Checks on the ACCESS specifier. */
2111 if (open
->access
&& open
->access
->expr_type
== EXPR_CONSTANT
)
2113 static const char *access_f95
[] = { "SEQUENTIAL", "DIRECT", NULL
};
2114 static const char *access_f2003
[] = { "STREAM", NULL
};
2115 static const char *access_gnu
[] = { "APPEND", NULL
};
2117 if (!is_char_type ("ACCESS", open
->access
))
2120 if (!compare_to_allowed_values ("ACCESS", access_f95
, access_f2003
,
2122 open
->access
->value
.character
.string
,
2127 /* Checks on the ACTION specifier. */
2128 if (open
->action
&& open
->action
->expr_type
== EXPR_CONSTANT
)
2130 gfc_char_t
*str
= open
->action
->value
.character
.string
;
2131 static const char *action
[] = { "READ", "WRITE", "READWRITE", NULL
};
2133 if (!is_char_type ("ACTION", open
->action
))
2136 if (!compare_to_allowed_values ("ACTION", action
, NULL
, NULL
,
2140 /* With READONLY, only allow ACTION='READ'. */
2141 if (open
->readonly
&& (gfc_wide_strlen (str
) != 4
2142 || gfc_wide_strncasecmp (str
, "READ", 4) != 0))
2144 gfc_error ("ACTION type conflicts with READONLY specifier at %C");
2148 /* If we see READONLY and no ACTION, set ACTION='READ'. */
2149 else if (open
->readonly
&& open
->action
== NULL
)
2151 open
->action
= gfc_get_character_expr (gfc_default_character_kind
,
2152 &gfc_current_locus
, "read", 4);
2155 /* Checks on the ASYNCHRONOUS specifier. */
2156 if (open
->asynchronous
)
2158 if (!gfc_notify_std (GFC_STD_F2003
, "ASYNCHRONOUS= at %C "
2159 "not allowed in Fortran 95"))
2162 if (!is_char_type ("ASYNCHRONOUS", open
->asynchronous
))
2165 if (open
->asynchronous
->expr_type
== EXPR_CONSTANT
)
2167 static const char * asynchronous
[] = { "YES", "NO", NULL
};
2169 if (!compare_to_allowed_values ("ASYNCHRONOUS", asynchronous
,
2170 NULL
, NULL
, open
->asynchronous
->value
.character
.string
,
2176 /* Checks on the BLANK specifier. */
2179 if (!gfc_notify_std (GFC_STD_F2003
, "BLANK= at %C "
2180 "not allowed in Fortran 95"))
2183 if (!is_char_type ("BLANK", open
->blank
))
2186 if (open
->blank
->expr_type
== EXPR_CONSTANT
)
2188 static const char *blank
[] = { "ZERO", "NULL", NULL
};
2190 if (!compare_to_allowed_values ("BLANK", blank
, NULL
, NULL
,
2191 open
->blank
->value
.character
.string
,
2197 /* Checks on the CARRIAGECONTROL specifier. */
2200 if (!is_char_type ("CARRIAGECONTROL", open
->cc
))
2203 if (open
->cc
->expr_type
== EXPR_CONSTANT
)
2205 static const char *cc
[] = { "LIST", "FORTRAN", "NONE", NULL
};
2206 if (!compare_to_allowed_values ("CARRIAGECONTROL", cc
, NULL
, NULL
,
2207 open
->cc
->value
.character
.string
,
2213 /* Checks on the DECIMAL specifier. */
2216 if (!gfc_notify_std (GFC_STD_F2003
, "DECIMAL= at %C "
2217 "not allowed in Fortran 95"))
2220 if (!is_char_type ("DECIMAL", open
->decimal
))
2223 if (open
->decimal
->expr_type
== EXPR_CONSTANT
)
2225 static const char * decimal
[] = { "COMMA", "POINT", NULL
};
2227 if (!compare_to_allowed_values ("DECIMAL", decimal
, NULL
, NULL
,
2228 open
->decimal
->value
.character
.string
,
2234 /* Checks on the DELIM specifier. */
2237 if (open
->delim
->expr_type
== EXPR_CONSTANT
)
2239 static const char *delim
[] = { "APOSTROPHE", "QUOTE", "NONE", NULL
};
2241 if (!is_char_type ("DELIM", open
->delim
))
2244 if (!compare_to_allowed_values ("DELIM", delim
, NULL
, NULL
,
2245 open
->delim
->value
.character
.string
,
2251 /* Checks on the ENCODING specifier. */
2254 if (!gfc_notify_std (GFC_STD_F2003
, "ENCODING= at %C "
2255 "not allowed in Fortran 95"))
2258 if (!is_char_type ("ENCODING", open
->encoding
))
2261 if (open
->encoding
->expr_type
== EXPR_CONSTANT
)
2263 static const char * encoding
[] = { "DEFAULT", "UTF-8", NULL
};
2265 if (!compare_to_allowed_values ("ENCODING", encoding
, NULL
, NULL
,
2266 open
->encoding
->value
.character
.string
,
2272 /* Checks on the FORM specifier. */
2273 if (open
->form
&& open
->form
->expr_type
== EXPR_CONSTANT
)
2275 static const char *form
[] = { "FORMATTED", "UNFORMATTED", NULL
};
2277 if (!is_char_type ("FORM", open
->form
))
2280 if (!compare_to_allowed_values ("FORM", form
, NULL
, NULL
,
2281 open
->form
->value
.character
.string
,
2286 /* Checks on the PAD specifier. */
2287 if (open
->pad
&& open
->pad
->expr_type
== EXPR_CONSTANT
)
2289 static const char *pad
[] = { "YES", "NO", NULL
};
2291 if (!is_char_type ("PAD", open
->pad
))
2294 if (!compare_to_allowed_values ("PAD", pad
, NULL
, NULL
,
2295 open
->pad
->value
.character
.string
,
2300 /* Checks on the POSITION specifier. */
2301 if (open
->position
&& open
->position
->expr_type
== EXPR_CONSTANT
)
2303 static const char *position
[] = { "ASIS", "REWIND", "APPEND", NULL
};
2305 if (!is_char_type ("POSITION", open
->position
))
2308 if (!compare_to_allowed_values ("POSITION", position
, NULL
, NULL
,
2309 open
->position
->value
.character
.string
,
2314 /* Checks on the ROUND specifier. */
2317 if (!gfc_notify_std (GFC_STD_F2003
, "ROUND= at %C "
2318 "not allowed in Fortran 95"))
2321 if (!is_char_type ("ROUND", open
->round
))
2324 if (open
->round
->expr_type
== EXPR_CONSTANT
)
2326 static const char * round
[] = { "UP", "DOWN", "ZERO", "NEAREST",
2327 "COMPATIBLE", "PROCESSOR_DEFINED",
2330 if (!compare_to_allowed_values ("ROUND", round
, NULL
, NULL
,
2331 open
->round
->value
.character
.string
,
2337 /* Checks on the SHARE specifier. */
2340 if (!is_char_type ("SHARE", open
->share
))
2343 if (open
->share
->expr_type
== EXPR_CONSTANT
)
2345 static const char *share
[] = { "DENYNONE", "DENYRW", NULL
};
2346 if (!compare_to_allowed_values ("SHARE", share
, NULL
, NULL
,
2347 open
->share
->value
.character
.string
,
2353 /* Checks on the SIGN specifier. */
2356 if (!gfc_notify_std (GFC_STD_F2003
, "SIGN= at %C "
2357 "not allowed in Fortran 95"))
2360 if (!is_char_type ("SIGN", open
->sign
))
2363 if (open
->sign
->expr_type
== EXPR_CONSTANT
)
2365 static const char * sign
[] = { "PLUS", "SUPPRESS", "PROCESSOR_DEFINED",
2368 if (!compare_to_allowed_values ("SIGN", sign
, NULL
, NULL
,
2369 open
->sign
->value
.character
.string
,
2375 #define warn_or_error(...) \
2378 gfc_warning (0, __VA_ARGS__); \
2381 gfc_error (__VA_ARGS__); \
2386 /* Checks on the RECL specifier. */
2387 if (open
->recl
&& open
->recl
->expr_type
== EXPR_CONSTANT
2388 && open
->recl
->ts
.type
== BT_INTEGER
2389 && mpz_sgn (open
->recl
->value
.integer
) != 1)
2391 warn_or_error ("RECL in OPEN statement at %C must be positive");
2394 /* Checks on the STATUS specifier. */
2395 if (open
->status
&& open
->status
->expr_type
== EXPR_CONSTANT
)
2397 static const char *status
[] = { "OLD", "NEW", "SCRATCH",
2398 "REPLACE", "UNKNOWN", NULL
};
2400 if (!is_char_type ("STATUS", open
->status
))
2403 if (!compare_to_allowed_values ("STATUS", status
, NULL
, NULL
,
2404 open
->status
->value
.character
.string
,
2408 /* F2003, 9.4.5: If the STATUS= specifier has the value NEW or REPLACE,
2409 the FILE= specifier shall appear. */
2410 if (open
->file
== NULL
2411 && (gfc_wide_strncasecmp (open
->status
->value
.character
.string
,
2413 || gfc_wide_strncasecmp (open
->status
->value
.character
.string
,
2416 char *s
= gfc_widechar_to_char (open
->status
->value
.character
.string
,
2418 warn_or_error ("The STATUS specified in OPEN statement at %C is "
2419 "%qs and no FILE specifier is present", s
);
2423 /* F2003, 9.4.5: If the STATUS= specifier has the value SCRATCH,
2424 the FILE= specifier shall not appear. */
2425 if (gfc_wide_strncasecmp (open
->status
->value
.character
.string
,
2426 "scratch", 7) == 0 && open
->file
)
2428 warn_or_error ("The STATUS specified in OPEN statement at %C "
2429 "cannot have the value SCRATCH if a FILE specifier "
2434 /* Things that are not allowed for unformatted I/O. */
2435 if (open
->form
&& open
->form
->expr_type
== EXPR_CONSTANT
2436 && (open
->delim
|| open
->decimal
|| open
->encoding
|| open
->round
2437 || open
->sign
|| open
->pad
|| open
->blank
)
2438 && gfc_wide_strncasecmp (open
->form
->value
.character
.string
,
2439 "unformatted", 11) == 0)
2441 const char *spec
= (open
->delim
? "DELIM "
2442 : (open
->pad
? "PAD " : open
->blank
2445 warn_or_error ("%s specifier at %C not allowed in OPEN statement for "
2446 "unformatted I/O", spec
);
2449 if (open
->recl
&& open
->access
&& open
->access
->expr_type
== EXPR_CONSTANT
2450 && gfc_wide_strncasecmp (open
->access
->value
.character
.string
,
2453 warn_or_error ("RECL specifier not allowed in OPEN statement at %C for "
2458 && open
->access
&& open
->access
->expr_type
== EXPR_CONSTANT
2459 && !(gfc_wide_strncasecmp (open
->access
->value
.character
.string
,
2460 "sequential", 10) == 0
2461 || gfc_wide_strncasecmp (open
->access
->value
.character
.string
,
2463 || gfc_wide_strncasecmp (open
->access
->value
.character
.string
,
2466 warn_or_error ("POSITION specifier in OPEN statement at %C only allowed "
2467 "for stream or sequential ACCESS");
2470 #undef warn_or_error
2472 new_st
.op
= EXEC_OPEN
;
2473 new_st
.ext
.open
= open
;
2477 gfc_syntax_error (ST_OPEN
);
2480 gfc_free_open (open
);
2485 /* Free a gfc_close structure an all its expressions. */
2488 gfc_free_close (gfc_close
*close
)
2493 gfc_free_expr (close
->unit
);
2494 gfc_free_expr (close
->iomsg
);
2495 gfc_free_expr (close
->iostat
);
2496 gfc_free_expr (close
->status
);
2501 /* Match elements of a CLOSE statement. */
2504 match_close_element (gfc_close
*close
)
2508 m
= match_etag (&tag_unit
, &close
->unit
);
2511 m
= match_etag (&tag_status
, &close
->status
);
2514 m
= match_etag (&tag_iomsg
, &close
->iomsg
);
2515 if (m
== MATCH_YES
&& !check_char_variable (close
->iomsg
))
2519 m
= match_out_tag (&tag_iostat
, &close
->iostat
);
2522 m
= match_ltag (&tag_err
, &close
->err
);
2530 /* Match a CLOSE statement. */
2533 gfc_match_close (void)
2539 m
= gfc_match_char ('(');
2543 close
= XCNEW (gfc_close
);
2545 m
= match_close_element (close
);
2547 if (m
== MATCH_ERROR
)
2551 m
= gfc_match_expr (&close
->unit
);
2554 if (m
== MATCH_ERROR
)
2560 if (gfc_match_char (')') == MATCH_YES
)
2562 if (gfc_match_char (',') != MATCH_YES
)
2565 m
= match_close_element (close
);
2566 if (m
== MATCH_ERROR
)
2572 if (gfc_match_eos () == MATCH_NO
)
2575 if (gfc_pure (NULL
))
2577 gfc_error ("CLOSE statement not allowed in PURE procedure at %C");
2581 gfc_unset_implicit_pure (NULL
);
2583 warn
= (close
->iostat
|| close
->err
) ? true : false;
2585 /* Checks on the STATUS specifier. */
2586 if (close
->status
&& close
->status
->expr_type
== EXPR_CONSTANT
)
2588 static const char *status
[] = { "KEEP", "DELETE", NULL
};
2590 if (!is_char_type ("STATUS", close
->status
))
2593 if (!compare_to_allowed_values ("STATUS", status
, NULL
, NULL
,
2594 close
->status
->value
.character
.string
,
2599 new_st
.op
= EXEC_CLOSE
;
2600 new_st
.ext
.close
= close
;
2604 gfc_syntax_error (ST_CLOSE
);
2607 gfc_free_close (close
);
2612 /* Resolve everything in a gfc_close structure. */
2615 gfc_resolve_close (gfc_close
*close
)
2617 RESOLVE_TAG (&tag_unit
, close
->unit
);
2618 RESOLVE_TAG (&tag_iomsg
, close
->iomsg
);
2619 RESOLVE_TAG (&tag_iostat
, close
->iostat
);
2620 RESOLVE_TAG (&tag_status
, close
->status
);
2622 if (!gfc_reference_st_label (close
->err
, ST_LABEL_TARGET
))
2625 if (close
->unit
== NULL
)
2627 /* Find a locus from one of the arguments to close, when UNIT is
2629 locus loc
= gfc_current_locus
;
2631 loc
= close
->status
->where
;
2632 else if (close
->iostat
)
2633 loc
= close
->iostat
->where
;
2634 else if (close
->iomsg
)
2635 loc
= close
->iomsg
->where
;
2636 else if (close
->err
)
2637 loc
= close
->err
->where
;
2639 gfc_error ("CLOSE statement at %L requires a UNIT number", &loc
);
2643 if (close
->unit
->expr_type
== EXPR_CONSTANT
2644 && close
->unit
->ts
.type
== BT_INTEGER
2645 && mpz_sgn (close
->unit
->value
.integer
) < 0)
2647 gfc_error ("UNIT number in CLOSE statement at %L must be non-negative",
2648 &close
->unit
->where
);
2655 /* Free a gfc_filepos structure. */
2658 gfc_free_filepos (gfc_filepos
*fp
)
2660 gfc_free_expr (fp
->unit
);
2661 gfc_free_expr (fp
->iomsg
);
2662 gfc_free_expr (fp
->iostat
);
2667 /* Match elements of a REWIND, BACKSPACE, ENDFILE, or FLUSH statement. */
2670 match_file_element (gfc_filepos
*fp
)
2674 m
= match_etag (&tag_unit
, &fp
->unit
);
2677 m
= match_etag (&tag_iomsg
, &fp
->iomsg
);
2678 if (m
== MATCH_YES
&& !check_char_variable (fp
->iomsg
))
2682 m
= match_out_tag (&tag_iostat
, &fp
->iostat
);
2685 m
= match_ltag (&tag_err
, &fp
->err
);
2693 /* Match the second half of the file-positioning statements, REWIND,
2694 BACKSPACE, ENDFILE, or the FLUSH statement. */
2697 match_filepos (gfc_statement st
, gfc_exec_op op
)
2702 fp
= XCNEW (gfc_filepos
);
2704 if (gfc_match_char ('(') == MATCH_NO
)
2706 m
= gfc_match_expr (&fp
->unit
);
2707 if (m
== MATCH_ERROR
)
2715 m
= match_file_element (fp
);
2716 if (m
== MATCH_ERROR
)
2720 m
= gfc_match_expr (&fp
->unit
);
2721 if (m
== MATCH_ERROR
|| m
== MATCH_NO
)
2727 if (gfc_match_char (')') == MATCH_YES
)
2729 if (gfc_match_char (',') != MATCH_YES
)
2732 m
= match_file_element (fp
);
2733 if (m
== MATCH_ERROR
)
2740 if (gfc_match_eos () != MATCH_YES
)
2743 if (gfc_pure (NULL
))
2745 gfc_error ("%s statement not allowed in PURE procedure at %C",
2746 gfc_ascii_statement (st
));
2751 gfc_unset_implicit_pure (NULL
);
2754 new_st
.ext
.filepos
= fp
;
2758 gfc_syntax_error (st
);
2761 gfc_free_filepos (fp
);
2767 gfc_resolve_filepos (gfc_filepos
*fp
)
2769 RESOLVE_TAG (&tag_unit
, fp
->unit
);
2770 RESOLVE_TAG (&tag_iostat
, fp
->iostat
);
2771 RESOLVE_TAG (&tag_iomsg
, fp
->iomsg
);
2772 if (!gfc_reference_st_label (fp
->err
, ST_LABEL_TARGET
))
2775 if (!fp
->unit
&& (fp
->iostat
|| fp
->iomsg
))
2778 where
= fp
->iostat
? fp
->iostat
->where
: fp
->iomsg
->where
;
2779 gfc_error ("UNIT number missing in statement at %L", &where
);
2783 if (fp
->unit
->expr_type
== EXPR_CONSTANT
2784 && fp
->unit
->ts
.type
== BT_INTEGER
2785 && mpz_sgn (fp
->unit
->value
.integer
) < 0)
2787 gfc_error ("UNIT number in statement at %L must be non-negative",
2796 /* Match the file positioning statements: ENDFILE, BACKSPACE, REWIND,
2797 and the FLUSH statement. */
2800 gfc_match_endfile (void)
2802 return match_filepos (ST_END_FILE
, EXEC_ENDFILE
);
2806 gfc_match_backspace (void)
2808 return match_filepos (ST_BACKSPACE
, EXEC_BACKSPACE
);
2812 gfc_match_rewind (void)
2814 return match_filepos (ST_REWIND
, EXEC_REWIND
);
2818 gfc_match_flush (void)
2820 if (!gfc_notify_std (GFC_STD_F2003
, "FLUSH statement at %C"))
2823 return match_filepos (ST_FLUSH
, EXEC_FLUSH
);
2826 /******************** Data Transfer Statements *********************/
2828 /* Return a default unit number. */
2831 default_unit (io_kind k
)
2840 return gfc_get_int_expr (gfc_default_integer_kind
, NULL
, unit
);
2844 /* Match a unit specification for a data transfer statement. */
2847 match_dt_unit (io_kind k
, gfc_dt
*dt
)
2852 if (gfc_match_char ('*') == MATCH_YES
)
2854 if (dt
->io_unit
!= NULL
)
2857 dt
->io_unit
= default_unit (k
);
2859 c
= gfc_peek_ascii_char ();
2861 gfc_error_now ("Missing format with default unit at %C");
2866 if (gfc_match_expr (&e
) == MATCH_YES
)
2868 if (dt
->io_unit
!= NULL
)
2881 gfc_error ("Duplicate UNIT specification at %C");
2886 /* Match a format specification. */
2889 match_dt_format (gfc_dt
*dt
)
2893 gfc_st_label
*label
;
2896 where
= gfc_current_locus
;
2898 if (gfc_match_char ('*') == MATCH_YES
)
2900 if (dt
->format_expr
!= NULL
|| dt
->format_label
!= NULL
)
2903 dt
->format_label
= &format_asterisk
;
2907 if ((m
= gfc_match_st_label (&label
)) == MATCH_YES
)
2911 /* Need to check if the format label is actually either an operand
2912 to a user-defined operator or is a kind type parameter. That is,
2913 print 2.ip.8 ! .ip. is a user-defined operator return CHARACTER.
2914 print 1_'(I0)', i ! 1_'(I0)' is a default character string. */
2916 gfc_gobble_whitespace ();
2917 c
= gfc_peek_ascii_char ();
2918 if (c
== '.' || c
== '_')
2919 gfc_current_locus
= where
;
2922 if (dt
->format_expr
!= NULL
|| dt
->format_label
!= NULL
)
2924 gfc_free_st_label (label
);
2928 if (!gfc_reference_st_label (label
, ST_LABEL_FORMAT
))
2931 dt
->format_label
= label
;
2935 else if (m
== MATCH_ERROR
)
2936 /* The label was zero or too large. Emit the correct diagnosis. */
2939 if (gfc_match_expr (&e
) == MATCH_YES
)
2941 if (dt
->format_expr
!= NULL
|| dt
->format_label
!= NULL
)
2946 dt
->format_expr
= e
;
2950 gfc_current_locus
= where
; /* The only case where we have to restore */
2955 gfc_error ("Duplicate format specification at %C");
2960 /* Traverse a namelist that is part of a READ statement to make sure
2961 that none of the variables in the namelist are INTENT(IN). Returns
2962 nonzero if we find such a variable. */
2965 check_namelist (gfc_symbol
*sym
)
2969 for (p
= sym
->namelist
; p
; p
= p
->next
)
2970 if (p
->sym
->attr
.intent
== INTENT_IN
)
2972 gfc_error ("Symbol %qs in namelist %qs is INTENT(IN) at %C",
2973 p
->sym
->name
, sym
->name
);
2981 /* Match a single data transfer element. */
2984 match_dt_element (io_kind k
, gfc_dt
*dt
)
2986 char name
[GFC_MAX_SYMBOL_LEN
+ 1];
2990 if (gfc_match (" unit =") == MATCH_YES
)
2992 m
= match_dt_unit (k
, dt
);
2997 if (gfc_match (" fmt =") == MATCH_YES
)
2999 m
= match_dt_format (dt
);
3004 if (gfc_match (" nml = %n", name
) == MATCH_YES
)
3006 if (dt
->namelist
!= NULL
)
3008 gfc_error ("Duplicate NML specification at %C");
3012 if (gfc_find_symbol (name
, NULL
, 1, &sym
))
3015 if (sym
== NULL
|| sym
->attr
.flavor
!= FL_NAMELIST
)
3017 gfc_error ("Symbol %qs at %C must be a NAMELIST group name",
3018 sym
!= NULL
? sym
->name
: name
);
3023 if (k
== M_READ
&& check_namelist (sym
))
3029 m
= match_etag (&tag_e_async
, &dt
->asynchronous
);
3030 if (m
== MATCH_YES
&& !is_char_type ("ASYNCHRONOUS", dt
->asynchronous
))
3034 m
= match_etag (&tag_e_blank
, &dt
->blank
);
3037 m
= match_etag (&tag_e_delim
, &dt
->delim
);
3040 m
= match_etag (&tag_e_pad
, &dt
->pad
);
3043 m
= match_etag (&tag_e_sign
, &dt
->sign
);
3046 m
= match_etag (&tag_e_round
, &dt
->round
);
3049 m
= match_out_tag (&tag_id
, &dt
->id
);
3052 m
= match_etag (&tag_e_decimal
, &dt
->decimal
);
3055 m
= match_etag (&tag_rec
, &dt
->rec
);
3058 m
= match_etag (&tag_spos
, &dt
->pos
);
3061 m
= match_etag (&tag_iomsg
, &dt
->iomsg
);
3062 if (m
== MATCH_YES
&& !check_char_variable (dt
->iomsg
))
3067 m
= match_out_tag (&tag_iostat
, &dt
->iostat
);
3070 m
= match_ltag (&tag_err
, &dt
->err
);
3072 dt
->err_where
= gfc_current_locus
;
3075 m
= match_etag (&tag_advance
, &dt
->advance
);
3078 m
= match_out_tag (&tag_size
, &dt
->size
);
3082 m
= match_ltag (&tag_end
, &dt
->end
);
3087 gfc_error ("END tag at %C not allowed in output statement");
3090 dt
->end_where
= gfc_current_locus
;
3095 m
= match_ltag (&tag_eor
, &dt
->eor
);
3097 dt
->eor_where
= gfc_current_locus
;
3105 /* Free a data transfer structure and everything below it. */
3108 gfc_free_dt (gfc_dt
*dt
)
3113 gfc_free_expr (dt
->io_unit
);
3114 gfc_free_expr (dt
->format_expr
);
3115 gfc_free_expr (dt
->rec
);
3116 gfc_free_expr (dt
->advance
);
3117 gfc_free_expr (dt
->iomsg
);
3118 gfc_free_expr (dt
->iostat
);
3119 gfc_free_expr (dt
->size
);
3120 gfc_free_expr (dt
->pad
);
3121 gfc_free_expr (dt
->delim
);
3122 gfc_free_expr (dt
->sign
);
3123 gfc_free_expr (dt
->round
);
3124 gfc_free_expr (dt
->blank
);
3125 gfc_free_expr (dt
->decimal
);
3126 gfc_free_expr (dt
->pos
);
3127 gfc_free_expr (dt
->dt_io_kind
);
3128 /* dt->extra_comma is a link to dt_io_kind if it is set. */
3133 /* Resolve everything in a gfc_dt structure. */
3136 gfc_resolve_dt (gfc_dt
*dt
, locus
*loc
)
3141 /* This is set in any case. */
3142 gcc_assert (dt
->dt_io_kind
);
3143 k
= dt
->dt_io_kind
->value
.iokind
;
3145 RESOLVE_TAG (&tag_format
, dt
->format_expr
);
3146 RESOLVE_TAG (&tag_rec
, dt
->rec
);
3147 RESOLVE_TAG (&tag_spos
, dt
->pos
);
3148 RESOLVE_TAG (&tag_advance
, dt
->advance
);
3149 RESOLVE_TAG (&tag_id
, dt
->id
);
3150 RESOLVE_TAG (&tag_iomsg
, dt
->iomsg
);
3151 RESOLVE_TAG (&tag_iostat
, dt
->iostat
);
3152 RESOLVE_TAG (&tag_size
, dt
->size
);
3153 RESOLVE_TAG (&tag_e_pad
, dt
->pad
);
3154 RESOLVE_TAG (&tag_e_delim
, dt
->delim
);
3155 RESOLVE_TAG (&tag_e_sign
, dt
->sign
);
3156 RESOLVE_TAG (&tag_e_round
, dt
->round
);
3157 RESOLVE_TAG (&tag_e_blank
, dt
->blank
);
3158 RESOLVE_TAG (&tag_e_decimal
, dt
->decimal
);
3159 RESOLVE_TAG (&tag_e_async
, dt
->asynchronous
);
3164 gfc_error ("UNIT not specified at %L", loc
);
3168 if (gfc_resolve_expr (e
)
3169 && (e
->ts
.type
!= BT_INTEGER
3170 && (e
->ts
.type
!= BT_CHARACTER
|| e
->expr_type
!= EXPR_VARIABLE
)))
3172 /* If there is no extra comma signifying the "format" form of the IO
3173 statement, then this must be an error. */
3174 if (!dt
->extra_comma
)
3176 gfc_error ("UNIT specification at %L must be an INTEGER expression "
3177 "or a CHARACTER variable", &e
->where
);
3182 /* At this point, we have an extra comma. If io_unit has arrived as
3183 type character, we assume its really the "format" form of the I/O
3184 statement. We set the io_unit to the default unit and format to
3185 the character expression. See F95 Standard section 9.4. */
3186 if (e
->ts
.type
== BT_CHARACTER
&& (k
== M_READ
|| k
== M_PRINT
))
3188 dt
->format_expr
= dt
->io_unit
;
3189 dt
->io_unit
= default_unit (k
);
3191 /* Nullify this pointer now so that a warning/error is not
3192 triggered below for the "Extension". */
3193 dt
->extra_comma
= NULL
;
3198 gfc_error ("Invalid form of WRITE statement at %L, UNIT required",
3199 &dt
->extra_comma
->where
);
3205 if (e
->ts
.type
== BT_CHARACTER
)
3207 if (gfc_has_vector_index (e
))
3209 gfc_error ("Internal unit with vector subscript at %L", &e
->where
);
3213 /* If we are writing, make sure the internal unit can be changed. */
3214 gcc_assert (k
!= M_PRINT
);
3216 && !gfc_check_vardef_context (e
, false, false, false,
3217 _("internal unit in WRITE")))
3221 if (e
->rank
&& e
->ts
.type
!= BT_CHARACTER
)
3223 gfc_error ("External IO UNIT cannot be an array at %L", &e
->where
);
3227 if (e
->expr_type
== EXPR_CONSTANT
&& e
->ts
.type
== BT_INTEGER
3228 && mpz_sgn (e
->value
.integer
) < 0)
3230 gfc_error ("UNIT number in statement at %L must be non-negative",
3235 /* If we are reading and have a namelist, check that all namelist symbols
3236 can appear in a variable definition context. */
3237 if (k
== M_READ
&& dt
->namelist
)
3240 for (n
= dt
->namelist
->namelist
; n
; n
= n
->next
)
3245 e
= gfc_get_variable_expr (gfc_find_sym_in_symtree (n
->sym
));
3246 t
= gfc_check_vardef_context (e
, false, false, false, NULL
);
3251 gfc_error ("NAMELIST %qs in READ statement at %L contains"
3252 " the symbol %qs which may not appear in a"
3253 " variable definition context",
3254 dt
->namelist
->name
, loc
, n
->sym
->name
);
3261 && !gfc_notify_std (GFC_STD_LEGACY
, "Comma before i/o item list at %L",
3262 &dt
->extra_comma
->where
))
3267 if (!gfc_reference_st_label (dt
->err
, ST_LABEL_TARGET
))
3269 if (dt
->err
->defined
== ST_LABEL_UNKNOWN
)
3271 gfc_error ("ERR tag label %d at %L not defined",
3272 dt
->err
->value
, &dt
->err_where
);
3279 if (!gfc_reference_st_label (dt
->end
, ST_LABEL_TARGET
))
3281 if (dt
->end
->defined
== ST_LABEL_UNKNOWN
)
3283 gfc_error ("END tag label %d at %L not defined",
3284 dt
->end
->value
, &dt
->end_where
);
3291 if (!gfc_reference_st_label (dt
->eor
, ST_LABEL_TARGET
))
3293 if (dt
->eor
->defined
== ST_LABEL_UNKNOWN
)
3295 gfc_error ("EOR tag label %d at %L not defined",
3296 dt
->eor
->value
, &dt
->eor_where
);
3301 /* Check the format label actually exists. */
3302 if (dt
->format_label
&& dt
->format_label
!= &format_asterisk
3303 && dt
->format_label
->defined
== ST_LABEL_UNKNOWN
)
3305 gfc_error ("FORMAT label %d at %L not defined", dt
->format_label
->value
,
3314 /* Given an io_kind, return its name. */
3317 io_kind_name (io_kind k
)
3336 gfc_internal_error ("io_kind_name(): bad I/O-kind");
3343 /* Match an IO iteration statement of the form:
3345 ( [<IO element> ,] <IO element>, I = <expr>, <expr> [, <expr> ] )
3347 which is equivalent to a single IO element. This function is
3348 mutually recursive with match_io_element(). */
3350 static match
match_io_element (io_kind
, gfc_code
**);
3353 match_io_iterator (io_kind k
, gfc_code
**result
)
3355 gfc_code
*head
, *tail
, *new_code
;
3363 old_loc
= gfc_current_locus
;
3365 if (gfc_match_char ('(') != MATCH_YES
)
3368 m
= match_io_element (k
, &head
);
3371 if (m
!= MATCH_YES
|| gfc_match_char (',') != MATCH_YES
)
3377 /* Can't be anything but an IO iterator. Build a list. */
3378 iter
= gfc_get_iterator ();
3382 m
= gfc_match_iterator (iter
, 0);
3383 if (m
== MATCH_ERROR
)
3387 gfc_check_do_variable (iter
->var
->symtree
);
3391 m
= match_io_element (k
, &new_code
);
3392 if (m
== MATCH_ERROR
)
3401 tail
= gfc_append_code (tail
, new_code
);
3403 if (gfc_match_char (',') != MATCH_YES
)
3412 if (gfc_match_char (')') != MATCH_YES
)
3415 new_code
= gfc_get_code (EXEC_DO
);
3416 new_code
->ext
.iterator
= iter
;
3418 new_code
->block
= gfc_get_code (EXEC_DO
);
3419 new_code
->block
->next
= head
;
3425 gfc_error ("Syntax error in I/O iterator at %C");
3429 gfc_free_iterator (iter
, 1);
3430 gfc_free_statements (head
);
3431 gfc_current_locus
= old_loc
;
3436 /* Match a single element of an IO list, which is either a single
3437 expression or an IO Iterator. */
3440 match_io_element (io_kind k
, gfc_code
**cpp
)
3448 m
= match_io_iterator (k
, cpp
);
3454 m
= gfc_match_variable (&expr
, 0);
3456 gfc_error ("Expected variable in READ statement at %C");
3460 m
= gfc_match_expr (&expr
);
3462 gfc_error ("Expected expression in %s statement at %C",
3466 if (m
== MATCH_YES
&& k
== M_READ
&& gfc_check_do_variable (expr
->symtree
))
3471 gfc_free_expr (expr
);
3475 cp
= gfc_get_code (EXEC_TRANSFER
);
3478 cp
->ext
.dt
= current_dt
;
3485 /* Match an I/O list, building gfc_code structures as we go. */
3488 match_io_list (io_kind k
, gfc_code
**head_p
)
3490 gfc_code
*head
, *tail
, *new_code
;
3493 *head_p
= head
= tail
= NULL
;
3494 if (gfc_match_eos () == MATCH_YES
)
3499 m
= match_io_element (k
, &new_code
);
3500 if (m
== MATCH_ERROR
)
3505 tail
= gfc_append_code (tail
, new_code
);
3509 if (gfc_match_eos () == MATCH_YES
)
3511 if (gfc_match_char (',') != MATCH_YES
)
3519 gfc_error ("Syntax error in %s statement at %C", io_kind_name (k
));
3522 gfc_free_statements (head
);
3527 /* Attach the data transfer end node. */
3530 terminate_io (gfc_code
*io_code
)
3534 if (io_code
== NULL
)
3535 io_code
= new_st
.block
;
3537 c
= gfc_get_code (EXEC_DT_END
);
3539 /* Point to structure that is already there */
3540 c
->ext
.dt
= new_st
.ext
.dt
;
3541 gfc_append_code (io_code
, c
);
3545 /* Check the constraints for a data transfer statement. The majority of the
3546 constraints appearing in 9.4 of the standard appear here. Some are handled
3547 in resolve_tag and others in gfc_resolve_dt. */
3550 check_io_constraints (io_kind k
, gfc_dt
*dt
, gfc_code
*io_code
,
3553 #define io_constraint(condition,msg,arg)\
3556 gfc_error(msg,arg);\
3562 gfc_symbol
*sym
= NULL
;
3563 bool warn
, unformatted
;
3565 warn
= (dt
->err
|| dt
->iostat
) ? true : false;
3566 unformatted
= dt
->format_expr
== NULL
&& dt
->format_label
== NULL
3567 && dt
->namelist
== NULL
;
3572 if (expr
&& expr
->expr_type
== EXPR_VARIABLE
3573 && expr
->ts
.type
== BT_CHARACTER
)
3575 sym
= expr
->symtree
->n
.sym
;
3577 io_constraint (k
== M_WRITE
&& sym
->attr
.intent
== INTENT_IN
,
3578 "Internal file at %L must not be INTENT(IN)",
3581 io_constraint (gfc_has_vector_index (dt
->io_unit
),
3582 "Internal file incompatible with vector subscript at %L",
3585 io_constraint (dt
->rec
!= NULL
,
3586 "REC tag at %L is incompatible with internal file",
3589 io_constraint (dt
->pos
!= NULL
,
3590 "POS tag at %L is incompatible with internal file",
3593 io_constraint (unformatted
,
3594 "Unformatted I/O not allowed with internal unit at %L",
3595 &dt
->io_unit
->where
);
3597 io_constraint (dt
->asynchronous
!= NULL
,
3598 "ASYNCHRONOUS tag at %L not allowed with internal file",
3599 &dt
->asynchronous
->where
);
3601 if (dt
->namelist
!= NULL
)
3603 if (!gfc_notify_std (GFC_STD_F2003
, "Internal file at %L with "
3604 "namelist", &expr
->where
))
3608 io_constraint (dt
->advance
!= NULL
,
3609 "ADVANCE tag at %L is incompatible with internal file",
3610 &dt
->advance
->where
);
3613 if (expr
&& expr
->ts
.type
!= BT_CHARACTER
)
3616 io_constraint (gfc_pure (NULL
) && (k
== M_READ
|| k
== M_WRITE
),
3617 "IO UNIT in %s statement at %C must be "
3618 "an internal file in a PURE procedure",
3621 if (k
== M_READ
|| k
== M_WRITE
)
3622 gfc_unset_implicit_pure (NULL
);
3627 io_constraint (dt
->end
, "END tag not allowed with output at %L",
3630 io_constraint (dt
->eor
, "EOR tag not allowed with output at %L",
3633 io_constraint (dt
->blank
, "BLANK= specifier not allowed with output at %L",
3636 io_constraint (dt
->pad
, "PAD= specifier not allowed with output at %L",
3639 io_constraint (dt
->size
, "SIZE= specifier not allowed with output at %L",
3644 io_constraint (dt
->size
&& dt
->advance
== NULL
,
3645 "SIZE tag at %L requires an ADVANCE tag",
3648 io_constraint (dt
->eor
&& dt
->advance
== NULL
,
3649 "EOR tag at %L requires an ADVANCE tag",
3653 if (dt
->asynchronous
)
3655 static const char * asynchronous
[] = { "YES", "NO", NULL
};
3657 if (!gfc_reduce_init_expr (dt
->asynchronous
))
3659 gfc_error ("ASYNCHRONOUS= specifier at %L must be an initialization "
3660 "expression", &dt
->asynchronous
->where
);
3664 if (!is_char_type ("ASYNCHRONOUS", dt
->asynchronous
))
3667 if (!compare_to_allowed_values
3668 ("ASYNCHRONOUS", asynchronous
, NULL
, NULL
,
3669 dt
->asynchronous
->value
.character
.string
,
3670 io_kind_name (k
), warn
))
3678 || gfc_wide_strlen (dt
->asynchronous
->value
.character
.string
) != 3
3679 || gfc_wide_strncasecmp (dt
->asynchronous
->value
.character
.string
,
3681 io_constraint (not_yes
,
3682 "ID= specifier at %L must be with ASYNCHRONOUS='yes' "
3683 "specifier", &dt
->id
->where
);
3688 if (!gfc_notify_std (GFC_STD_F2003
, "DECIMAL= at %C "
3689 "not allowed in Fortran 95"))
3692 if (dt
->decimal
->expr_type
== EXPR_CONSTANT
)
3694 static const char * decimal
[] = { "COMMA", "POINT", NULL
};
3696 if (!is_char_type ("DECIMAL", dt
->decimal
))
3699 if (!compare_to_allowed_values ("DECIMAL", decimal
, NULL
, NULL
,
3700 dt
->decimal
->value
.character
.string
,
3701 io_kind_name (k
), warn
))
3704 io_constraint (unformatted
,
3705 "the DECIMAL= specifier at %L must be with an "
3706 "explicit format expression", &dt
->decimal
->where
);
3712 if (!gfc_notify_std (GFC_STD_F2003
, "BLANK= at %C "
3713 "not allowed in Fortran 95"))
3716 if (!is_char_type ("BLANK", dt
->blank
))
3719 if (dt
->blank
->expr_type
== EXPR_CONSTANT
)
3721 static const char * blank
[] = { "NULL", "ZERO", NULL
};
3724 if (!compare_to_allowed_values ("BLANK", blank
, NULL
, NULL
,
3725 dt
->blank
->value
.character
.string
,
3726 io_kind_name (k
), warn
))
3729 io_constraint (unformatted
,
3730 "the BLANK= specifier at %L must be with an "
3731 "explicit format expression", &dt
->blank
->where
);
3737 if (!gfc_notify_std (GFC_STD_F2003
, "PAD= at %C "
3738 "not allowed in Fortran 95"))
3741 if (!is_char_type ("PAD", dt
->pad
))
3744 if (dt
->pad
->expr_type
== EXPR_CONSTANT
)
3746 static const char * pad
[] = { "YES", "NO", NULL
};
3748 if (!compare_to_allowed_values ("PAD", pad
, NULL
, NULL
,
3749 dt
->pad
->value
.character
.string
,
3750 io_kind_name (k
), warn
))
3753 io_constraint (unformatted
,
3754 "the PAD= specifier at %L must be with an "
3755 "explicit format expression", &dt
->pad
->where
);
3761 if (!gfc_notify_std (GFC_STD_F2003
, "ROUND= at %C "
3762 "not allowed in Fortran 95"))
3765 if (!is_char_type ("ROUND", dt
->round
))
3768 if (dt
->round
->expr_type
== EXPR_CONSTANT
)
3770 static const char * round
[] = { "UP", "DOWN", "ZERO", "NEAREST",
3771 "COMPATIBLE", "PROCESSOR_DEFINED",
3774 if (!compare_to_allowed_values ("ROUND", round
, NULL
, NULL
,
3775 dt
->round
->value
.character
.string
,
3776 io_kind_name (k
), warn
))
3783 /* When implemented, change the following to use gfc_notify_std F2003.
3784 if (gfc_notify_std (GFC_STD_F2003, "SIGN= at %C "
3785 "not allowed in Fortran 95") == false)
3786 return MATCH_ERROR; */
3788 if (!is_char_type ("SIGN", dt
->sign
))
3791 if (dt
->sign
->expr_type
== EXPR_CONSTANT
)
3793 static const char * sign
[] = { "PLUS", "SUPPRESS", "PROCESSOR_DEFINED",
3796 if (!compare_to_allowed_values ("SIGN", sign
, NULL
, NULL
,
3797 dt
->sign
->value
.character
.string
,
3798 io_kind_name (k
), warn
))
3801 io_constraint (unformatted
,
3802 "SIGN= specifier at %L must be with an "
3803 "explicit format expression", &dt
->sign
->where
);
3805 io_constraint (k
== M_READ
,
3806 "SIGN= specifier at %L not allowed in a "
3807 "READ statement", &dt
->sign
->where
);
3813 if (!gfc_notify_std (GFC_STD_F2003
, "DELIM= at %C "
3814 "not allowed in Fortran 95"))
3817 if (!is_char_type ("DELIM", dt
->delim
))
3820 if (dt
->delim
->expr_type
== EXPR_CONSTANT
)
3822 static const char *delim
[] = { "APOSTROPHE", "QUOTE", "NONE", NULL
};
3824 if (!compare_to_allowed_values ("DELIM", delim
, NULL
, NULL
,
3825 dt
->delim
->value
.character
.string
,
3826 io_kind_name (k
), warn
))
3829 io_constraint (k
== M_READ
,
3830 "DELIM= specifier at %L not allowed in a "
3831 "READ statement", &dt
->delim
->where
);
3833 io_constraint (dt
->format_label
!= &format_asterisk
3834 && dt
->namelist
== NULL
,
3835 "DELIM= specifier at %L must have FMT=*",
3838 io_constraint (unformatted
&& dt
->namelist
== NULL
,
3839 "DELIM= specifier at %L must be with FMT=* or "
3840 "NML= specifier", &dt
->delim
->where
);
3846 io_constraint (io_code
&& dt
->namelist
,
3847 "NAMELIST cannot be followed by IO-list at %L",
3850 io_constraint (dt
->format_expr
,
3851 "IO spec-list cannot contain both NAMELIST group name "
3852 "and format specification at %L",
3853 &dt
->format_expr
->where
);
3855 io_constraint (dt
->format_label
,
3856 "IO spec-list cannot contain both NAMELIST group name "
3857 "and format label at %L", spec_end
);
3859 io_constraint (dt
->rec
,
3860 "NAMELIST IO is not allowed with a REC= specifier "
3861 "at %L", &dt
->rec
->where
);
3863 io_constraint (dt
->advance
,
3864 "NAMELIST IO is not allowed with a ADVANCE= specifier "
3865 "at %L", &dt
->advance
->where
);
3870 io_constraint (dt
->end
,
3871 "An END tag is not allowed with a "
3872 "REC= specifier at %L", &dt
->end_where
);
3874 io_constraint (dt
->format_label
== &format_asterisk
,
3875 "FMT=* is not allowed with a REC= specifier "
3878 io_constraint (dt
->pos
,
3879 "POS= is not allowed with REC= specifier "
3880 "at %L", &dt
->pos
->where
);
3885 int not_yes
, not_no
;
3888 io_constraint (dt
->format_label
== &format_asterisk
,
3889 "List directed format(*) is not allowed with a "
3890 "ADVANCE= specifier at %L.", &expr
->where
);
3892 io_constraint (unformatted
,
3893 "the ADVANCE= specifier at %L must appear with an "
3894 "explicit format expression", &expr
->where
);
3896 if (expr
->expr_type
== EXPR_CONSTANT
&& expr
->ts
.type
== BT_CHARACTER
)
3898 const gfc_char_t
*advance
= expr
->value
.character
.string
;
3899 not_no
= gfc_wide_strlen (advance
) != 2
3900 || gfc_wide_strncasecmp (advance
, "no", 2) != 0;
3901 not_yes
= gfc_wide_strlen (advance
) != 3
3902 || gfc_wide_strncasecmp (advance
, "yes", 3) != 0;
3910 io_constraint (not_no
&& not_yes
,
3911 "ADVANCE= specifier at %L must have value = "
3912 "YES or NO.", &expr
->where
);
3914 io_constraint (dt
->size
&& not_no
&& k
== M_READ
,
3915 "SIZE tag at %L requires an ADVANCE = %<NO%>",
3918 io_constraint (dt
->eor
&& not_no
&& k
== M_READ
,
3919 "EOR tag at %L requires an ADVANCE = %<NO%>",
3923 expr
= dt
->format_expr
;
3924 if (!gfc_simplify_expr (expr
, 0)
3925 || !check_format_string (expr
, k
== M_READ
))
3930 #undef io_constraint
3933 /* Match a READ, WRITE or PRINT statement. */
3936 match_io (io_kind k
)
3938 char name
[GFC_MAX_SYMBOL_LEN
+ 1];
3943 locus spec_end
, control
;
3947 where
= gfc_current_locus
;
3949 current_dt
= dt
= XCNEW (gfc_dt
);
3950 m
= gfc_match_char ('(');
3953 where
= gfc_current_locus
;
3956 else if (k
== M_PRINT
)
3958 /* Treat the non-standard case of PRINT namelist. */
3959 if ((gfc_current_form
== FORM_FIXED
|| gfc_peek_ascii_char () == ' ')
3960 && gfc_match_name (name
) == MATCH_YES
)
3962 gfc_find_symbol (name
, NULL
, 1, &sym
);
3963 if (sym
&& sym
->attr
.flavor
== FL_NAMELIST
)
3965 if (!gfc_notify_std (GFC_STD_GNU
, "PRINT namelist at "
3966 "%C is an extension"))
3972 dt
->io_unit
= default_unit (k
);
3977 gfc_current_locus
= where
;
3981 if (gfc_current_form
== FORM_FREE
)
3983 char c
= gfc_peek_ascii_char ();
3984 if (c
!= ' ' && c
!= '*' && c
!= '\'' && c
!= '"')
3991 m
= match_dt_format (dt
);
3992 if (m
== MATCH_ERROR
)
3998 dt
->io_unit
= default_unit (k
);
4003 /* Before issuing an error for a malformed 'print (1,*)' type of
4004 error, check for a default-char-expr of the form ('(I0)'). */
4007 control
= gfc_current_locus
;
4010 /* Reset current locus to get the initial '(' in an expression. */
4011 gfc_current_locus
= where
;
4012 dt
->format_expr
= NULL
;
4013 m
= match_dt_format (dt
);
4015 if (m
== MATCH_ERROR
)
4017 if (m
== MATCH_NO
|| dt
->format_expr
== NULL
)
4021 dt
->io_unit
= default_unit (k
);
4026 /* Commit any pending symbols now so that when we undo
4027 symbols later we wont lose them. */
4028 gfc_commit_symbols ();
4029 /* Reset current locus to get the initial '(' in an expression. */
4030 gfc_current_locus
= where
;
4031 dt
->format_expr
= NULL
;
4032 m
= gfc_match_expr (&dt
->format_expr
);
4036 && dt
->format_expr
->ts
.type
== BT_CHARACTER
)
4039 dt
->io_unit
= default_unit (k
);
4044 gfc_free_expr (dt
->format_expr
);
4045 dt
->format_expr
= NULL
;
4046 gfc_current_locus
= control
;
4052 gfc_undo_symbols ();
4053 gfc_free_expr (dt
->format_expr
);
4054 dt
->format_expr
= NULL
;
4055 gfc_current_locus
= control
;
4061 /* Match a control list */
4062 if (match_dt_element (k
, dt
) == MATCH_YES
)
4064 if (match_dt_unit (k
, dt
) != MATCH_YES
)
4067 if (gfc_match_char (')') == MATCH_YES
)
4069 if (gfc_match_char (',') != MATCH_YES
)
4072 m
= match_dt_element (k
, dt
);
4075 if (m
== MATCH_ERROR
)
4078 m
= match_dt_format (dt
);
4081 if (m
== MATCH_ERROR
)
4084 where
= gfc_current_locus
;
4086 m
= gfc_match_name (name
);
4089 gfc_find_symbol (name
, NULL
, 1, &sym
);
4090 if (sym
&& sym
->attr
.flavor
== FL_NAMELIST
)
4093 if (k
== M_READ
&& check_namelist (sym
))
4102 gfc_current_locus
= where
;
4104 goto loop
; /* No matches, try regular elements */
4107 if (gfc_match_char (')') == MATCH_YES
)
4109 if (gfc_match_char (',') != MATCH_YES
)
4115 m
= match_dt_element (k
, dt
);
4118 if (m
== MATCH_ERROR
)
4121 if (gfc_match_char (')') == MATCH_YES
)
4123 if (gfc_match_char (',') != MATCH_YES
)
4129 /* Used in check_io_constraints, where no locus is available. */
4130 spec_end
= gfc_current_locus
;
4132 /* Save the IO kind for later use. */
4133 dt
->dt_io_kind
= gfc_get_iokind_expr (&gfc_current_locus
, k
);
4135 /* Optional leading comma (non-standard). We use a gfc_expr structure here
4136 to save the locus. This is used later when resolving transfer statements
4137 that might have a format expression without unit number. */
4138 if (!comma_flag
&& gfc_match_char (',') == MATCH_YES
)
4139 dt
->extra_comma
= dt
->dt_io_kind
;
4142 if (gfc_match_eos () != MATCH_YES
)
4144 if (comma_flag
&& gfc_match_char (',') != MATCH_YES
)
4146 gfc_error ("Expected comma in I/O list at %C");
4151 m
= match_io_list (k
, &io_code
);
4152 if (m
== MATCH_ERROR
)
4158 /* See if we want to use defaults for missing exponents in real transfers. */
4160 dt
->default_exp
= 1;
4162 /* A full IO statement has been matched. Check the constraints. spec_end is
4163 supplied for cases where no locus is supplied. */
4164 m
= check_io_constraints (k
, dt
, io_code
, &spec_end
);
4166 if (m
== MATCH_ERROR
)
4169 new_st
.op
= (k
== M_READ
) ? EXEC_READ
: EXEC_WRITE
;
4171 new_st
.block
= gfc_get_code (new_st
.op
);
4172 new_st
.block
->next
= io_code
;
4174 terminate_io (io_code
);
4179 gfc_error ("Syntax error in %s statement at %C", io_kind_name (k
));
4189 gfc_match_read (void)
4191 return match_io (M_READ
);
4196 gfc_match_write (void)
4198 return match_io (M_WRITE
);
4203 gfc_match_print (void)
4207 m
= match_io (M_PRINT
);
4211 if (gfc_pure (NULL
))
4213 gfc_error ("PRINT statement at %C not allowed within PURE procedure");
4217 gfc_unset_implicit_pure (NULL
);
4223 /* Free a gfc_inquire structure. */
4226 gfc_free_inquire (gfc_inquire
*inquire
)
4229 if (inquire
== NULL
)
4232 gfc_free_expr (inquire
->unit
);
4233 gfc_free_expr (inquire
->file
);
4234 gfc_free_expr (inquire
->iomsg
);
4235 gfc_free_expr (inquire
->iostat
);
4236 gfc_free_expr (inquire
->exist
);
4237 gfc_free_expr (inquire
->opened
);
4238 gfc_free_expr (inquire
->number
);
4239 gfc_free_expr (inquire
->named
);
4240 gfc_free_expr (inquire
->name
);
4241 gfc_free_expr (inquire
->access
);
4242 gfc_free_expr (inquire
->sequential
);
4243 gfc_free_expr (inquire
->direct
);
4244 gfc_free_expr (inquire
->form
);
4245 gfc_free_expr (inquire
->formatted
);
4246 gfc_free_expr (inquire
->unformatted
);
4247 gfc_free_expr (inquire
->recl
);
4248 gfc_free_expr (inquire
->nextrec
);
4249 gfc_free_expr (inquire
->blank
);
4250 gfc_free_expr (inquire
->position
);
4251 gfc_free_expr (inquire
->action
);
4252 gfc_free_expr (inquire
->read
);
4253 gfc_free_expr (inquire
->write
);
4254 gfc_free_expr (inquire
->readwrite
);
4255 gfc_free_expr (inquire
->delim
);
4256 gfc_free_expr (inquire
->encoding
);
4257 gfc_free_expr (inquire
->pad
);
4258 gfc_free_expr (inquire
->iolength
);
4259 gfc_free_expr (inquire
->convert
);
4260 gfc_free_expr (inquire
->strm_pos
);
4261 gfc_free_expr (inquire
->asynchronous
);
4262 gfc_free_expr (inquire
->decimal
);
4263 gfc_free_expr (inquire
->pending
);
4264 gfc_free_expr (inquire
->id
);
4265 gfc_free_expr (inquire
->sign
);
4266 gfc_free_expr (inquire
->size
);
4267 gfc_free_expr (inquire
->round
);
4268 gfc_free_expr (inquire
->share
);
4269 gfc_free_expr (inquire
->cc
);
4274 /* Match an element of an INQUIRE statement. */
4276 #define RETM if (m != MATCH_NO) return m;
4279 match_inquire_element (gfc_inquire
*inquire
)
4283 m
= match_etag (&tag_unit
, &inquire
->unit
);
4284 RETM m
= match_etag (&tag_file
, &inquire
->file
);
4285 RETM m
= match_ltag (&tag_err
, &inquire
->err
);
4286 RETM m
= match_etag (&tag_iomsg
, &inquire
->iomsg
);
4287 if (m
== MATCH_YES
&& !check_char_variable (inquire
->iomsg
))
4289 RETM m
= match_out_tag (&tag_iostat
, &inquire
->iostat
);
4290 RETM m
= match_vtag (&tag_exist
, &inquire
->exist
);
4291 RETM m
= match_vtag (&tag_opened
, &inquire
->opened
);
4292 RETM m
= match_vtag (&tag_named
, &inquire
->named
);
4293 RETM m
= match_vtag (&tag_name
, &inquire
->name
);
4294 RETM m
= match_out_tag (&tag_number
, &inquire
->number
);
4295 RETM m
= match_vtag (&tag_s_access
, &inquire
->access
);
4296 RETM m
= match_vtag (&tag_sequential
, &inquire
->sequential
);
4297 RETM m
= match_vtag (&tag_direct
, &inquire
->direct
);
4298 RETM m
= match_vtag (&tag_s_form
, &inquire
->form
);
4299 RETM m
= match_vtag (&tag_formatted
, &inquire
->formatted
);
4300 RETM m
= match_vtag (&tag_unformatted
, &inquire
->unformatted
);
4301 RETM m
= match_out_tag (&tag_s_recl
, &inquire
->recl
);
4302 RETM m
= match_out_tag (&tag_nextrec
, &inquire
->nextrec
);
4303 RETM m
= match_vtag (&tag_s_blank
, &inquire
->blank
);
4304 RETM m
= match_vtag (&tag_s_position
, &inquire
->position
);
4305 RETM m
= match_vtag (&tag_s_action
, &inquire
->action
);
4306 RETM m
= match_vtag (&tag_read
, &inquire
->read
);
4307 RETM m
= match_vtag (&tag_write
, &inquire
->write
);
4308 RETM m
= match_vtag (&tag_readwrite
, &inquire
->readwrite
);
4309 RETM m
= match_vtag (&tag_s_async
, &inquire
->asynchronous
);
4310 if (m
== MATCH_YES
&& !is_char_type ("ASYNCHRONOUS", inquire
->asynchronous
))
4312 RETM m
= match_vtag (&tag_s_delim
, &inquire
->delim
);
4313 RETM m
= match_vtag (&tag_s_decimal
, &inquire
->decimal
);
4314 RETM m
= match_out_tag (&tag_size
, &inquire
->size
);
4315 RETM m
= match_vtag (&tag_s_encoding
, &inquire
->encoding
);
4316 RETM m
= match_vtag (&tag_s_round
, &inquire
->round
);
4317 RETM m
= match_vtag (&tag_s_sign
, &inquire
->sign
);
4318 RETM m
= match_vtag (&tag_s_pad
, &inquire
->pad
);
4319 RETM m
= match_out_tag (&tag_iolength
, &inquire
->iolength
);
4320 RETM m
= match_vtag (&tag_convert
, &inquire
->convert
);
4321 RETM m
= match_out_tag (&tag_strm_out
, &inquire
->strm_pos
);
4322 RETM m
= match_vtag (&tag_pending
, &inquire
->pending
);
4323 RETM m
= match_vtag (&tag_id
, &inquire
->id
);
4324 RETM m
= match_vtag (&tag_s_iqstream
, &inquire
->iqstream
);
4325 RETM m
= match_dec_vtag (&tag_v_share
, &inquire
->share
);
4326 RETM m
= match_dec_vtag (&tag_v_cc
, &inquire
->cc
);
4327 RETM
return MATCH_NO
;
4334 gfc_match_inquire (void)
4336 gfc_inquire
*inquire
;
4341 m
= gfc_match_char ('(');
4345 inquire
= XCNEW (gfc_inquire
);
4347 loc
= gfc_current_locus
;
4349 m
= match_inquire_element (inquire
);
4350 if (m
== MATCH_ERROR
)
4354 m
= gfc_match_expr (&inquire
->unit
);
4355 if (m
== MATCH_ERROR
)
4361 /* See if we have the IOLENGTH form of the inquire statement. */
4362 if (inquire
->iolength
!= NULL
)
4364 if (gfc_match_char (')') != MATCH_YES
)
4367 m
= match_io_list (M_INQUIRE
, &code
);
4368 if (m
== MATCH_ERROR
)
4373 new_st
.op
= EXEC_IOLENGTH
;
4374 new_st
.expr1
= inquire
->iolength
;
4375 new_st
.ext
.inquire
= inquire
;
4377 if (gfc_pure (NULL
))
4379 gfc_free_statements (code
);
4380 gfc_error ("INQUIRE statement not allowed in PURE procedure at %C");
4384 gfc_unset_implicit_pure (NULL
);
4386 new_st
.block
= gfc_get_code (EXEC_IOLENGTH
);
4387 terminate_io (code
);
4388 new_st
.block
->next
= code
;
4392 /* At this point, we have the non-IOLENGTH inquire statement. */
4395 if (gfc_match_char (')') == MATCH_YES
)
4397 if (gfc_match_char (',') != MATCH_YES
)
4400 m
= match_inquire_element (inquire
);
4401 if (m
== MATCH_ERROR
)
4406 if (inquire
->iolength
!= NULL
)
4408 gfc_error ("IOLENGTH tag invalid in INQUIRE statement at %C");
4413 if (gfc_match_eos () != MATCH_YES
)
4416 if (inquire
->unit
!= NULL
&& inquire
->file
!= NULL
)
4418 gfc_error ("INQUIRE statement at %L cannot contain both FILE and "
4419 "UNIT specifiers", &loc
);
4423 if (inquire
->unit
== NULL
&& inquire
->file
== NULL
)
4425 gfc_error ("INQUIRE statement at %L requires either FILE or "
4426 "UNIT specifier", &loc
);
4430 if (inquire
->unit
!= NULL
&& inquire
->unit
->expr_type
== EXPR_CONSTANT
4431 && inquire
->unit
->ts
.type
== BT_INTEGER
4432 && ((mpz_get_si (inquire
->unit
->value
.integer
) == GFC_INTERNAL_UNIT4
)
4433 || (mpz_get_si (inquire
->unit
->value
.integer
) == GFC_INTERNAL_UNIT
)))
4435 gfc_error ("UNIT number in INQUIRE statement at %L can not "
4436 "be %d", &loc
, (int) mpz_get_si (inquire
->unit
->value
.integer
));
4440 if (gfc_pure (NULL
))
4442 gfc_error ("INQUIRE statement not allowed in PURE procedure at %C");
4446 gfc_unset_implicit_pure (NULL
);
4448 if (inquire
->id
!= NULL
&& inquire
->pending
== NULL
)
4450 gfc_error ("INQUIRE statement at %L requires a PENDING= specifier with "
4451 "the ID= specifier", &loc
);
4455 new_st
.op
= EXEC_INQUIRE
;
4456 new_st
.ext
.inquire
= inquire
;
4460 gfc_syntax_error (ST_INQUIRE
);
4463 gfc_free_inquire (inquire
);
4468 /* Resolve everything in a gfc_inquire structure. */
4471 gfc_resolve_inquire (gfc_inquire
*inquire
)
4473 RESOLVE_TAG (&tag_unit
, inquire
->unit
);
4474 RESOLVE_TAG (&tag_file
, inquire
->file
);
4475 RESOLVE_TAG (&tag_id
, inquire
->id
);
4477 /* For INQUIRE, all tags except FILE, ID and UNIT are variable definition
4478 contexts. Thus, use an extended RESOLVE_TAG macro for that. */
4479 #define INQUIRE_RESOLVE_TAG(tag, expr) \
4480 RESOLVE_TAG (tag, expr); \
4484 sprintf (context, _("%s tag with INQUIRE"), (tag)->name); \
4485 if (gfc_check_vardef_context ((expr), false, false, false, \
4486 context) == false) \
4489 INQUIRE_RESOLVE_TAG (&tag_iomsg
, inquire
->iomsg
);
4490 INQUIRE_RESOLVE_TAG (&tag_iostat
, inquire
->iostat
);
4491 INQUIRE_RESOLVE_TAG (&tag_exist
, inquire
->exist
);
4492 INQUIRE_RESOLVE_TAG (&tag_opened
, inquire
->opened
);
4493 INQUIRE_RESOLVE_TAG (&tag_number
, inquire
->number
);
4494 INQUIRE_RESOLVE_TAG (&tag_named
, inquire
->named
);
4495 INQUIRE_RESOLVE_TAG (&tag_name
, inquire
->name
);
4496 INQUIRE_RESOLVE_TAG (&tag_s_access
, inquire
->access
);
4497 INQUIRE_RESOLVE_TAG (&tag_sequential
, inquire
->sequential
);
4498 INQUIRE_RESOLVE_TAG (&tag_direct
, inquire
->direct
);
4499 INQUIRE_RESOLVE_TAG (&tag_s_form
, inquire
->form
);
4500 INQUIRE_RESOLVE_TAG (&tag_formatted
, inquire
->formatted
);
4501 INQUIRE_RESOLVE_TAG (&tag_unformatted
, inquire
->unformatted
);
4502 INQUIRE_RESOLVE_TAG (&tag_s_recl
, inquire
->recl
);
4503 INQUIRE_RESOLVE_TAG (&tag_nextrec
, inquire
->nextrec
);
4504 INQUIRE_RESOLVE_TAG (&tag_s_blank
, inquire
->blank
);
4505 INQUIRE_RESOLVE_TAG (&tag_s_position
, inquire
->position
);
4506 INQUIRE_RESOLVE_TAG (&tag_s_action
, inquire
->action
);
4507 INQUIRE_RESOLVE_TAG (&tag_read
, inquire
->read
);
4508 INQUIRE_RESOLVE_TAG (&tag_write
, inquire
->write
);
4509 INQUIRE_RESOLVE_TAG (&tag_readwrite
, inquire
->readwrite
);
4510 INQUIRE_RESOLVE_TAG (&tag_s_delim
, inquire
->delim
);
4511 INQUIRE_RESOLVE_TAG (&tag_s_pad
, inquire
->pad
);
4512 INQUIRE_RESOLVE_TAG (&tag_s_encoding
, inquire
->encoding
);
4513 INQUIRE_RESOLVE_TAG (&tag_s_round
, inquire
->round
);
4514 INQUIRE_RESOLVE_TAG (&tag_iolength
, inquire
->iolength
);
4515 INQUIRE_RESOLVE_TAG (&tag_convert
, inquire
->convert
);
4516 INQUIRE_RESOLVE_TAG (&tag_strm_out
, inquire
->strm_pos
);
4517 INQUIRE_RESOLVE_TAG (&tag_s_async
, inquire
->asynchronous
);
4518 INQUIRE_RESOLVE_TAG (&tag_s_sign
, inquire
->sign
);
4519 INQUIRE_RESOLVE_TAG (&tag_s_round
, inquire
->round
);
4520 INQUIRE_RESOLVE_TAG (&tag_pending
, inquire
->pending
);
4521 INQUIRE_RESOLVE_TAG (&tag_size
, inquire
->size
);
4522 INQUIRE_RESOLVE_TAG (&tag_s_decimal
, inquire
->decimal
);
4523 INQUIRE_RESOLVE_TAG (&tag_s_iqstream
, inquire
->iqstream
);
4524 INQUIRE_RESOLVE_TAG (&tag_v_share
, inquire
->share
);
4525 INQUIRE_RESOLVE_TAG (&tag_v_cc
, inquire
->cc
);
4526 #undef INQUIRE_RESOLVE_TAG
4528 if (!gfc_reference_st_label (inquire
->err
, ST_LABEL_TARGET
))
4536 gfc_free_wait (gfc_wait
*wait
)
4541 gfc_free_expr (wait
->unit
);
4542 gfc_free_expr (wait
->iostat
);
4543 gfc_free_expr (wait
->iomsg
);
4544 gfc_free_expr (wait
->id
);
4550 gfc_resolve_wait (gfc_wait
*wait
)
4552 RESOLVE_TAG (&tag_unit
, wait
->unit
);
4553 RESOLVE_TAG (&tag_iomsg
, wait
->iomsg
);
4554 RESOLVE_TAG (&tag_iostat
, wait
->iostat
);
4555 RESOLVE_TAG (&tag_id
, wait
->id
);
4557 if (!gfc_reference_st_label (wait
->err
, ST_LABEL_TARGET
))
4560 if (!gfc_reference_st_label (wait
->end
, ST_LABEL_TARGET
))
4566 /* Match an element of a WAIT statement. */
4568 #define RETM if (m != MATCH_NO) return m;
4571 match_wait_element (gfc_wait
*wait
)
4575 m
= match_etag (&tag_unit
, &wait
->unit
);
4576 RETM m
= match_ltag (&tag_err
, &wait
->err
);
4577 RETM m
= match_ltag (&tag_end
, &wait
->eor
);
4578 RETM m
= match_ltag (&tag_eor
, &wait
->end
);
4579 RETM m
= match_etag (&tag_iomsg
, &wait
->iomsg
);
4580 if (m
== MATCH_YES
&& !check_char_variable (wait
->iomsg
))
4582 RETM m
= match_out_tag (&tag_iostat
, &wait
->iostat
);
4583 RETM m
= match_etag (&tag_id
, &wait
->id
);
4584 RETM
return MATCH_NO
;
4591 gfc_match_wait (void)
4596 m
= gfc_match_char ('(');
4600 wait
= XCNEW (gfc_wait
);
4602 m
= match_wait_element (wait
);
4603 if (m
== MATCH_ERROR
)
4607 m
= gfc_match_expr (&wait
->unit
);
4608 if (m
== MATCH_ERROR
)
4616 if (gfc_match_char (')') == MATCH_YES
)
4618 if (gfc_match_char (',') != MATCH_YES
)
4621 m
= match_wait_element (wait
);
4622 if (m
== MATCH_ERROR
)
4628 if (!gfc_notify_std (GFC_STD_F2003
, "WAIT at %C "
4629 "not allowed in Fortran 95"))
4632 if (gfc_pure (NULL
))
4634 gfc_error ("WAIT statement not allowed in PURE procedure at %C");
4638 gfc_unset_implicit_pure (NULL
);
4640 new_st
.op
= EXEC_WAIT
;
4641 new_st
.ext
.wait
= wait
;
4646 gfc_syntax_error (ST_WAIT
);
4649 gfc_free_wait (wait
);