1 /* Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
2 Contributed by Andy Vaught
3 Namelist input contributed by Paul Thomas
5 This file is part of the GNU Fortran 95 runtime library (libgfortran).
7 Libgfortran is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 In addition to the permissions in the GNU General Public License, the
13 Free Software Foundation gives you unlimited permission to link the
14 compiled version of this file into combinations with other programs,
15 and to distribute those combinations without any restriction coming
16 from the use of this file. (The General Public License restrictions
17 do apply in other respects; for example, they cover modification of
18 the file, and distribution when not linked into a combine
21 Libgfortran is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with Libgfortran; see the file COPYING. If not, write to
28 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
29 Boston, MA 02110-1301, USA. */
35 #include "libgfortran.h"
39 /* List directed input. Several parsing subroutines are practically
40 reimplemented from formatted input, the reason being that there are
41 all kinds of small differences between formatted and list directed
45 /* Subroutines for reading characters from the input. Because a
46 repeat count is ambiguous with an integer, we have to read the
47 whole digit string before seeing if there is a '*' which signals
48 the repeat count. Since we can have a lot of potential leading
49 zeros, we have to be able to back up by arbitrary amount. Because
50 the input might not be seekable, we have to buffer the data
53 #define CASE_DIGITS case '0': case '1': case '2': case '3': case '4': \
54 case '5': case '6': case '7': case '8': case '9'
56 #define CASE_SEPARATORS case ' ': case ',': case '/': case '\n': case '\t': \
59 /* This macro assumes that we're operating on a variable. */
61 #define is_separator(c) (c == '/' || c == ',' || c == '\n' || c == ' ' \
62 || c == '\t' || c == '\r')
64 /* Maximum repeat count. Less than ten times the maximum signed int32. */
66 #define MAX_REPEAT 200000000
69 /* Save a character to a string buffer, enlarging it as necessary. */
72 push_char (st_parameter_dt
*dtp
, char c
)
76 if (dtp
->u
.p
.saved_string
== NULL
)
78 if (dtp
->u
.p
.scratch
== NULL
)
79 dtp
->u
.p
.scratch
= get_mem (SCRATCH_SIZE
);
80 dtp
->u
.p
.saved_string
= dtp
->u
.p
.scratch
;
81 memset (dtp
->u
.p
.saved_string
, 0, SCRATCH_SIZE
);
82 dtp
->u
.p
.saved_length
= SCRATCH_SIZE
;
83 dtp
->u
.p
.saved_used
= 0;
86 if (dtp
->u
.p
.saved_used
>= dtp
->u
.p
.saved_length
)
88 dtp
->u
.p
.saved_length
= 2 * dtp
->u
.p
.saved_length
;
89 new = get_mem (2 * dtp
->u
.p
.saved_length
);
91 memset (new, 0, 2 * dtp
->u
.p
.saved_length
);
93 memcpy (new, dtp
->u
.p
.saved_string
, dtp
->u
.p
.saved_used
);
94 if (dtp
->u
.p
.saved_string
!= dtp
->u
.p
.scratch
)
95 free_mem (dtp
->u
.p
.saved_string
);
97 dtp
->u
.p
.saved_string
= new;
100 dtp
->u
.p
.saved_string
[dtp
->u
.p
.saved_used
++] = c
;
104 /* Free the input buffer if necessary. */
107 free_saved (st_parameter_dt
*dtp
)
109 if (dtp
->u
.p
.saved_string
== NULL
)
112 if (dtp
->u
.p
.saved_string
!= dtp
->u
.p
.scratch
)
113 free_mem (dtp
->u
.p
.saved_string
);
115 dtp
->u
.p
.saved_string
= NULL
;
116 dtp
->u
.p
.saved_used
= 0;
120 /* Free the line buffer if necessary. */
123 free_line (st_parameter_dt
*dtp
)
125 if (dtp
->u
.p
.line_buffer
== NULL
)
128 free_mem (dtp
->u
.p
.line_buffer
);
129 dtp
->u
.p
.line_buffer
= NULL
;
134 next_char (st_parameter_dt
*dtp
)
140 if (dtp
->u
.p
.last_char
!= '\0')
143 c
= dtp
->u
.p
.last_char
;
144 dtp
->u
.p
.last_char
= '\0';
148 /* Read from line_buffer if enabled. */
150 if (dtp
->u
.p
.line_buffer_enabled
)
154 c
= dtp
->u
.p
.line_buffer
[dtp
->u
.p
.item_count
];
155 if (c
!= '\0' && dtp
->u
.p
.item_count
< 64)
157 dtp
->u
.p
.line_buffer
[dtp
->u
.p
.item_count
] = '\0';
158 dtp
->u
.p
.item_count
++;
162 dtp
->u
.p
.item_count
= 0;
163 dtp
->u
.p
.line_buffer_enabled
= 0;
166 /* Handle the end-of-record and end-of-file conditions for
167 internal array unit. */
168 if (is_array_io(dtp
))
171 longjmp (*dtp
->u
.p
.eof_jump
, 1);
173 /* Check for "end-of-record" condition. */
174 if (dtp
->u
.p
.current_unit
->bytes_left
== 0)
177 record
= next_array_record (dtp
, dtp
->u
.p
.current_unit
->ls
);
179 /* Check for "end-of-file" condition. */
186 record
*= dtp
->u
.p
.current_unit
->recl
;
187 if (sseek (dtp
->u
.p
.current_unit
->s
, record
) == FAILURE
)
188 longjmp (*dtp
->u
.p
.eof_jump
, 1);
190 dtp
->u
.p
.current_unit
->bytes_left
= dtp
->u
.p
.current_unit
->recl
;
195 /* Get the next character and handle end-of-record conditions. */
199 p
= salloc_r (dtp
->u
.p
.current_unit
->s
, &length
);
201 if (is_stream_io (dtp
))
202 dtp
->u
.p
.current_unit
->strm_pos
++;
204 if (is_internal_unit(dtp
))
206 if (is_array_io(dtp
))
208 /* End of record is handled in the next pass through, above. The
209 check for NULL here is cautionary. */
212 generate_error (&dtp
->common
, ERROR_INTERNAL_UNIT
, NULL
);
216 dtp
->u
.p
.current_unit
->bytes_left
--;
222 longjmp (*dtp
->u
.p
.eof_jump
, 1);
233 generate_error (&dtp
->common
, ERROR_OS
, NULL
);
237 longjmp (*dtp
->u
.p
.eof_jump
, 1);
241 dtp
->u
.p
.at_eol
= (c
== '\n' || c
== '\r');
246 /* Push a character back onto the input. */
249 unget_char (st_parameter_dt
*dtp
, char c
)
251 dtp
->u
.p
.last_char
= c
;
255 /* Skip over spaces in the input. Returns the nonspace character that
256 terminated the eating and also places it back on the input. */
259 eat_spaces (st_parameter_dt
*dtp
)
267 while (c
== ' ' || c
== '\t');
274 /* Skip over a separator. Technically, we don't always eat the whole
275 separator. This is because if we've processed the last input item,
276 then a separator is unnecessary. Plus the fact that operating
277 systems usually deliver console input on a line basis.
279 The upshot is that if we see a newline as part of reading a
280 separator, we stop reading. If there are more input items, we
281 continue reading the separator with finish_separator() which takes
282 care of the fact that we may or may not have seen a comma as part
286 eat_separator (st_parameter_dt
*dtp
)
291 dtp
->u
.p
.comma_flag
= 0;
297 dtp
->u
.p
.comma_flag
= 1;
302 dtp
->u
.p
.input_complete
= 1;
318 if (dtp
->u
.p
.namelist_mode
)
319 { /* Eat a namelist comment. */
327 /* Fall Through... */
336 /* Finish processing a separator that was interrupted by a newline.
337 If we're here, then another data item is present, so we finish what
338 we started on the previous line. */
341 finish_separator (st_parameter_dt
*dtp
)
352 if (dtp
->u
.p
.comma_flag
)
356 c
= eat_spaces (dtp
);
357 if (c
== '\n' || c
== '\r')
364 dtp
->u
.p
.input_complete
= 1;
365 if (!dtp
->u
.p
.namelist_mode
)
374 if (dtp
->u
.p
.namelist_mode
)
390 /* This function reads characters through to the end of the current line and
391 just ignores them. */
394 eat_line (st_parameter_dt
*dtp
)
397 if (!is_internal_unit (dtp
))
404 /* This function is needed to catch bad conversions so that namelist can
405 attempt to see if dtp->u.p.saved_string contains a new object name rather
409 nml_bad_return (st_parameter_dt
*dtp
, char c
)
411 if (dtp
->u
.p
.namelist_mode
)
413 dtp
->u
.p
.nml_read_error
= 1;
420 /* Convert an unsigned string to an integer. The length value is -1
421 if we are working on a repeat count. Returns nonzero if we have a
422 range problem. As a side effect, frees the dtp->u.p.saved_string. */
425 convert_integer (st_parameter_dt
*dtp
, int length
, int negative
)
427 char c
, *buffer
, message
[100];
429 GFC_INTEGER_LARGEST v
, max
, max10
;
431 buffer
= dtp
->u
.p
.saved_string
;
434 max
= (length
== -1) ? MAX_REPEAT
: max_value (length
, 1);
459 set_integer (dtp
->u
.p
.value
, v
, length
);
463 dtp
->u
.p
.repeat_count
= v
;
465 if (dtp
->u
.p
.repeat_count
== 0)
467 st_sprintf (message
, "Zero repeat count in item %d of list input",
468 dtp
->u
.p
.item_count
);
470 generate_error (&dtp
->common
, ERROR_READ_VALUE
, message
);
480 st_sprintf (message
, "Repeat count overflow in item %d of list input",
481 dtp
->u
.p
.item_count
);
483 st_sprintf (message
, "Integer overflow while reading item %d",
484 dtp
->u
.p
.item_count
);
487 generate_error (&dtp
->common
, ERROR_READ_VALUE
, message
);
493 /* Parse a repeat count for logical and complex values which cannot
494 begin with a digit. Returns nonzero if we are done, zero if we
495 should continue on. */
498 parse_repeat (st_parameter_dt
*dtp
)
500 char c
, message
[100];
526 repeat
= 10 * repeat
+ c
- '0';
528 if (repeat
> MAX_REPEAT
)
531 "Repeat count overflow in item %d of list input",
532 dtp
->u
.p
.item_count
);
534 generate_error (&dtp
->common
, ERROR_READ_VALUE
, message
);
544 "Zero repeat count in item %d of list input",
545 dtp
->u
.p
.item_count
);
547 generate_error (&dtp
->common
, ERROR_READ_VALUE
, message
);
559 dtp
->u
.p
.repeat_count
= repeat
;
566 st_sprintf (message
, "Bad repeat count in item %d of list input",
567 dtp
->u
.p
.item_count
);
568 generate_error (&dtp
->common
, ERROR_READ_VALUE
, message
);
573 /* To read a logical we have to look ahead in the input stream to make sure
574 there is not an equal sign indicating a variable name. To do this we use
575 line_buffer to point to a temporary buffer, pushing characters there for
576 possible later reading. */
579 l_push_char (st_parameter_dt
*dtp
, char c
)
581 if (dtp
->u
.p
.line_buffer
== NULL
)
583 dtp
->u
.p
.line_buffer
= get_mem (SCRATCH_SIZE
);
584 memset (dtp
->u
.p
.line_buffer
, 0, SCRATCH_SIZE
);
587 dtp
->u
.p
.line_buffer
[dtp
->u
.p
.item_count
++] = c
;
591 /* Read a logical character on the input. */
594 read_logical (st_parameter_dt
*dtp
, int length
)
596 char c
, message
[100];
599 if (parse_repeat (dtp
))
602 c
= tolower (next_char (dtp
));
603 l_push_char (dtp
, c
);
609 l_push_char (dtp
, c
);
611 if (!is_separator(c
))
619 l_push_char (dtp
, c
);
621 if (!is_separator(c
))
627 c
= tolower (next_char (dtp
));
645 return; /* Null value. */
651 dtp
->u
.p
.saved_type
= BT_LOGICAL
;
652 dtp
->u
.p
.saved_length
= length
;
654 /* Eat trailing garbage. */
659 while (!is_separator (c
));
663 dtp
->u
.p
.item_count
= 0;
664 dtp
->u
.p
.line_buffer_enabled
= 0;
665 set_integer ((int *) dtp
->u
.p
.value
, v
, length
);
672 for(i
= 0; i
< 63; i
++)
677 /* All done if this is not a namelist read. */
678 if (!dtp
->u
.p
.namelist_mode
)
691 l_push_char (dtp
, c
);
694 dtp
->u
.p
.nml_read_error
= 1;
695 dtp
->u
.p
.line_buffer_enabled
= 1;
696 dtp
->u
.p
.item_count
= 0;
706 if (nml_bad_return (dtp
, c
))
711 st_sprintf (message
, "Bad logical value while reading item %d",
712 dtp
->u
.p
.item_count
);
713 generate_error (&dtp
->common
, ERROR_READ_VALUE
, message
);
718 dtp
->u
.p
.item_count
= 0;
719 dtp
->u
.p
.line_buffer_enabled
= 0;
720 dtp
->u
.p
.saved_type
= BT_LOGICAL
;
721 dtp
->u
.p
.saved_length
= length
;
722 set_integer ((int *) dtp
->u
.p
.value
, v
, length
);
728 /* Reading integers is tricky because we can actually be reading a
729 repeat count. We have to store the characters in a buffer because
730 we could be reading an integer that is larger than the default int
731 used for repeat counts. */
734 read_integer (st_parameter_dt
*dtp
, int length
)
736 char c
, message
[100];
746 /* Fall through... */
752 CASE_SEPARATORS
: /* Single null. */
765 /* Take care of what may be a repeat count. */
777 push_char (dtp
, '\0');
780 CASE_SEPARATORS
: /* Not a repeat count. */
789 if (convert_integer (dtp
, -1, 0))
792 /* Get the real integer. */
807 /* Fall through... */
838 if (nml_bad_return (dtp
, c
))
843 st_sprintf (message
, "Bad integer for item %d in list input",
844 dtp
->u
.p
.item_count
);
845 generate_error (&dtp
->common
, ERROR_READ_VALUE
, message
);
853 push_char (dtp
, '\0');
854 if (convert_integer (dtp
, length
, negative
))
861 dtp
->u
.p
.saved_type
= BT_INTEGER
;
865 /* Read a character variable. */
868 read_character (st_parameter_dt
*dtp
, int length
__attribute__ ((unused
)))
870 char c
, quote
, message
[100];
872 quote
= ' '; /* Space means no quote character. */
882 unget_char (dtp
, c
); /* NULL value. */
892 if (dtp
->u
.p
.namelist_mode
)
901 /* Deal with a possible repeat count. */
914 goto done
; /* String was only digits! */
917 push_char (dtp
, '\0');
922 goto get_string
; /* Not a repeat count after all. */
927 if (convert_integer (dtp
, -1, 0))
930 /* Now get the real string. */
936 unget_char (dtp
, c
); /* Repeated NULL values. */
964 /* See if we have a doubled quote character or the end of
970 push_char (dtp
, quote
);
984 if (c
!= '\n' && c
!= '\r')
994 /* At this point, we have to have a separator, or else the string is
998 if (is_separator (c
))
1000 unget_char (dtp
, c
);
1001 eat_separator (dtp
);
1002 dtp
->u
.p
.saved_type
= BT_CHARACTER
;
1007 st_sprintf (message
, "Invalid string input in item %d",
1008 dtp
->u
.p
.item_count
);
1009 generate_error (&dtp
->common
, ERROR_READ_VALUE
, message
);
1014 /* Parse a component of a complex constant or a real number that we
1015 are sure is already there. This is a straight real number parser. */
1018 parse_real (st_parameter_dt
*dtp
, void *buffer
, int length
)
1020 char c
, message
[100];
1023 c
= next_char (dtp
);
1024 if (c
== '-' || c
== '+')
1027 c
= next_char (dtp
);
1030 if (!isdigit (c
) && c
!= '.')
1035 seen_dp
= (c
== '.') ? 1 : 0;
1039 c
= next_char (dtp
);
1058 push_char (dtp
, 'e');
1063 push_char (dtp
, 'e');
1065 c
= next_char (dtp
);
1069 unget_char (dtp
, c
);
1078 c
= next_char (dtp
);
1079 if (c
!= '-' && c
!= '+')
1080 push_char (dtp
, '+');
1084 c
= next_char (dtp
);
1094 c
= next_char (dtp
);
1102 unget_char (dtp
, c
);
1111 unget_char (dtp
, c
);
1112 push_char (dtp
, '\0');
1114 m
= convert_real (dtp
, buffer
, dtp
->u
.p
.saved_string
, length
);
1121 if (nml_bad_return (dtp
, c
))
1126 st_sprintf (message
, "Bad floating point number for item %d",
1127 dtp
->u
.p
.item_count
);
1128 generate_error (&dtp
->common
, ERROR_READ_VALUE
, message
);
1134 /* Reading a complex number is straightforward because we can tell
1135 what it is right away. */
1138 read_complex (st_parameter_dt
*dtp
, int kind
, size_t size
)
1143 if (parse_repeat (dtp
))
1146 c
= next_char (dtp
);
1153 unget_char (dtp
, c
);
1154 eat_separator (dtp
);
1162 if (parse_real (dtp
, dtp
->u
.p
.value
, kind
))
1167 c
= next_char (dtp
);
1168 if (c
== '\n' || c
== '\r')
1171 unget_char (dtp
, c
);
1173 if (next_char (dtp
) != ',')
1178 c
= next_char (dtp
);
1179 if (c
== '\n' || c
== '\r')
1182 unget_char (dtp
, c
);
1184 if (parse_real (dtp
, dtp
->u
.p
.value
+ size
/ 2, kind
))
1188 if (next_char (dtp
) != ')')
1191 c
= next_char (dtp
);
1192 if (!is_separator (c
))
1195 unget_char (dtp
, c
);
1196 eat_separator (dtp
);
1199 dtp
->u
.p
.saved_type
= BT_COMPLEX
;
1204 if (nml_bad_return (dtp
, c
))
1209 st_sprintf (message
, "Bad complex value in item %d of list input",
1210 dtp
->u
.p
.item_count
);
1211 generate_error (&dtp
->common
, ERROR_READ_VALUE
, message
);
1215 /* Parse a real number with a possible repeat count. */
1218 read_real (st_parameter_dt
*dtp
, int length
)
1220 char c
, message
[100];
1225 c
= next_char (dtp
);
1242 unget_char (dtp
, c
); /* Single null. */
1243 eat_separator (dtp
);
1250 /* Get the digit string that might be a repeat count. */
1254 c
= next_char (dtp
);
1277 push_char (dtp
, 'e');
1279 c
= next_char (dtp
);
1283 push_char (dtp
, '\0');
1287 if (c
!= '\n' && c
!= ',' && c
!= '\r')
1288 unget_char (dtp
, c
);
1297 if (convert_integer (dtp
, -1, 0))
1300 /* Now get the number itself. */
1302 c
= next_char (dtp
);
1303 if (is_separator (c
))
1304 { /* Repeated null value. */
1305 unget_char (dtp
, c
);
1306 eat_separator (dtp
);
1310 if (c
!= '-' && c
!= '+')
1311 push_char (dtp
, '+');
1316 c
= next_char (dtp
);
1319 if (!isdigit (c
) && c
!= '.')
1335 c
= next_char (dtp
);
1361 push_char (dtp
, 'e');
1363 c
= next_char (dtp
);
1372 push_char (dtp
, 'e');
1374 c
= next_char (dtp
);
1375 if (c
!= '+' && c
!= '-')
1376 push_char (dtp
, '+');
1380 c
= next_char (dtp
);
1390 c
= next_char (dtp
);
1407 unget_char (dtp
, c
);
1408 eat_separator (dtp
);
1409 push_char (dtp
, '\0');
1410 if (convert_real (dtp
, dtp
->u
.p
.value
, dtp
->u
.p
.saved_string
, length
))
1414 dtp
->u
.p
.saved_type
= BT_REAL
;
1419 if (nml_bad_return (dtp
, c
))
1424 st_sprintf (message
, "Bad real number in item %d of list input",
1425 dtp
->u
.p
.item_count
);
1426 generate_error (&dtp
->common
, ERROR_READ_VALUE
, message
);
1430 /* Check the current type against the saved type to make sure they are
1431 compatible. Returns nonzero if incompatible. */
1434 check_type (st_parameter_dt
*dtp
, bt type
, int len
)
1438 if (dtp
->u
.p
.saved_type
!= BT_NULL
&& dtp
->u
.p
.saved_type
!= type
)
1440 st_sprintf (message
, "Read type %s where %s was expected for item %d",
1441 type_name (dtp
->u
.p
.saved_type
), type_name (type
),
1442 dtp
->u
.p
.item_count
);
1444 generate_error (&dtp
->common
, ERROR_READ_VALUE
, message
);
1448 if (dtp
->u
.p
.saved_type
== BT_NULL
|| dtp
->u
.p
.saved_type
== BT_CHARACTER
)
1451 if (dtp
->u
.p
.saved_length
!= len
)
1453 st_sprintf (message
,
1454 "Read kind %d %s where kind %d is required for item %d",
1455 dtp
->u
.p
.saved_length
, type_name (dtp
->u
.p
.saved_type
), len
,
1456 dtp
->u
.p
.item_count
);
1457 generate_error (&dtp
->common
, ERROR_READ_VALUE
, message
);
1465 /* Top level data transfer subroutine for list reads. Because we have
1466 to deal with repeat counts, the data item is always saved after
1467 reading, usually in the dtp->u.p.value[] array. If a repeat count is
1468 greater than one, we copy the data item multiple times. */
1471 list_formatted_read_scalar (st_parameter_dt
*dtp
, bt type
, void *p
, int kind
,
1478 dtp
->u
.p
.namelist_mode
= 0;
1480 dtp
->u
.p
.eof_jump
= &eof_jump
;
1481 if (setjmp (eof_jump
))
1483 generate_error (&dtp
->common
, ERROR_END
, NULL
);
1487 if (dtp
->u
.p
.first_item
)
1489 dtp
->u
.p
.first_item
= 0;
1490 dtp
->u
.p
.input_complete
= 0;
1491 dtp
->u
.p
.repeat_count
= 1;
1492 dtp
->u
.p
.at_eol
= 0;
1494 c
= eat_spaces (dtp
);
1495 if (is_separator (c
))
1497 /* Found a null value. */
1498 eat_separator (dtp
);
1499 dtp
->u
.p
.repeat_count
= 0;
1501 /* eat_separator sets this flag if the separator was a comma. */
1502 if (dtp
->u
.p
.comma_flag
)
1505 /* eat_separator sets this flag if the separator was a \n or \r. */
1506 if (dtp
->u
.p
.at_eol
)
1507 finish_separator (dtp
);
1515 if (dtp
->u
.p
.input_complete
)
1518 if (dtp
->u
.p
.repeat_count
> 0)
1520 if (check_type (dtp
, type
, kind
))
1525 if (dtp
->u
.p
.at_eol
)
1526 finish_separator (dtp
);
1530 /* Trailing spaces prior to end of line. */
1531 if (dtp
->u
.p
.at_eol
)
1532 finish_separator (dtp
);
1535 dtp
->u
.p
.saved_type
= BT_NULL
;
1536 dtp
->u
.p
.repeat_count
= 1;
1542 read_integer (dtp
, kind
);
1545 read_logical (dtp
, kind
);
1548 read_character (dtp
, kind
);
1551 read_real (dtp
, kind
);
1554 read_complex (dtp
, kind
, size
);
1557 internal_error (&dtp
->common
, "Bad type for list read");
1560 if (dtp
->u
.p
.saved_type
!= BT_CHARACTER
&& dtp
->u
.p
.saved_type
!= BT_NULL
)
1561 dtp
->u
.p
.saved_length
= size
;
1563 if ((dtp
->common
.flags
& IOPARM_LIBRETURN_MASK
) != IOPARM_LIBRETURN_OK
)
1567 switch (dtp
->u
.p
.saved_type
)
1573 memcpy (p
, dtp
->u
.p
.value
, size
);
1577 if (dtp
->u
.p
.saved_string
)
1579 m
= ((int) size
< dtp
->u
.p
.saved_used
)
1580 ? (int) size
: dtp
->u
.p
.saved_used
;
1581 memcpy (p
, dtp
->u
.p
.saved_string
, m
);
1584 /* Just delimiters encountered, nothing to copy but SPACE. */
1588 memset (((char *) p
) + m
, ' ', size
- m
);
1595 if (--dtp
->u
.p
.repeat_count
<= 0)
1599 dtp
->u
.p
.eof_jump
= NULL
;
1604 list_formatted_read (st_parameter_dt
*dtp
, bt type
, void *p
, int kind
,
1605 size_t size
, size_t nelems
)
1612 /* Big loop over all the elements. */
1613 for (elem
= 0; elem
< nelems
; elem
++)
1615 dtp
->u
.p
.item_count
++;
1616 list_formatted_read_scalar (dtp
, type
, tmp
+ size
*elem
, kind
, size
);
1621 /* Finish a list read. */
1624 finish_list_read (st_parameter_dt
*dtp
)
1630 if (dtp
->u
.p
.at_eol
)
1632 dtp
->u
.p
.at_eol
= 0;
1638 c
= next_char (dtp
);
1645 void namelist_read (st_parameter_dt *dtp)
1647 static void nml_match_name (char *name, int len)
1648 static int nml_query (st_parameter_dt *dtp)
1649 static int nml_get_obj_data (st_parameter_dt *dtp,
1650 namelist_info **prev_nl, char *)
1652 static void nml_untouch_nodes (st_parameter_dt *dtp)
1653 static namelist_info * find_nml_node (st_parameter_dt *dtp,
1655 static int nml_parse_qualifier(descriptor_dimension * ad,
1656 array_loop_spec * ls, int rank, char *)
1657 static void nml_touch_nodes (namelist_info * nl)
1658 static int nml_read_obj (namelist_info *nl, index_type offset,
1659 namelist_info **prev_nl, char *,
1660 index_type clow, index_type chigh)
1664 /* Inputs a rank-dimensional qualifier, which can contain
1665 singlets, doublets, triplets or ':' with the standard meanings. */
1668 nml_parse_qualifier (st_parameter_dt
*dtp
, descriptor_dimension
*ad
,
1669 array_loop_spec
*ls
, int rank
, char *parse_err_msg
)
1675 int is_array_section
;
1678 is_array_section
= 0;
1679 dtp
->u
.p
.expanded_read
= 0;
1681 /* The next character in the stream should be the '('. */
1683 c
= next_char (dtp
);
1685 /* Process the qualifier, by dimension and triplet. */
1687 for (dim
=0; dim
< rank
; dim
++ )
1689 for (indx
=0; indx
<3; indx
++)
1695 /* Process a potential sign. */
1696 c
= next_char (dtp
);
1707 unget_char (dtp
, c
);
1711 /* Process characters up to the next ':' , ',' or ')'. */
1714 c
= next_char (dtp
);
1719 is_array_section
= 1;
1723 if ((c
==',' && dim
== rank
-1)
1724 || (c
==')' && dim
< rank
-1))
1726 st_sprintf (parse_err_msg
,
1727 "Bad number of index fields");
1736 case ' ': case '\t':
1738 c
= next_char (dtp
);
1742 st_sprintf (parse_err_msg
, "Bad character in index");
1746 if ((c
== ',' || c
== ')') && indx
== 0
1747 && dtp
->u
.p
.saved_string
== 0)
1749 st_sprintf (parse_err_msg
, "Null index field");
1753 if ((c
== ':' && indx
== 1 && dtp
->u
.p
.saved_string
== 0)
1754 || (indx
== 2 && dtp
->u
.p
.saved_string
== 0))
1756 st_sprintf(parse_err_msg
, "Bad index triplet");
1760 /* If '( : ? )' or '( ? : )' break and flag read failure. */
1762 if ((c
== ':' && indx
== 0 && dtp
->u
.p
.saved_string
== 0)
1763 || (indx
==1 && dtp
->u
.p
.saved_string
== 0))
1769 /* Now read the index. */
1770 if (convert_integer (dtp
, sizeof(ssize_t
), neg
))
1772 st_sprintf (parse_err_msg
, "Bad integer in index");
1778 /* Feed the index values to the triplet arrays. */
1782 memcpy (&ls
[dim
].start
, dtp
->u
.p
.value
, sizeof(ssize_t
));
1784 memcpy (&ls
[dim
].end
, dtp
->u
.p
.value
, sizeof(ssize_t
));
1786 memcpy (&ls
[dim
].step
, dtp
->u
.p
.value
, sizeof(ssize_t
));
1789 /* Singlet or doublet indices. */
1790 if (c
==',' || c
==')')
1794 memcpy (&ls
[dim
].start
, dtp
->u
.p
.value
, sizeof(ssize_t
));
1796 /* If -std=f95/2003 or an array section is specified,
1797 do not allow excess data to be processed. */
1798 if (is_array_section
== 1
1799 || compile_options
.allow_std
< GFC_STD_GNU
)
1800 ls
[dim
].end
= ls
[dim
].start
;
1802 dtp
->u
.p
.expanded_read
= 1;
1808 /* Check the values of the triplet indices. */
1809 if ((ls
[dim
].start
> (ssize_t
)ad
[dim
].ubound
)
1810 || (ls
[dim
].start
< (ssize_t
)ad
[dim
].lbound
)
1811 || (ls
[dim
].end
> (ssize_t
)ad
[dim
].ubound
)
1812 || (ls
[dim
].end
< (ssize_t
)ad
[dim
].lbound
))
1814 st_sprintf (parse_err_msg
, "Index %d out of range", dim
+ 1);
1817 if (((ls
[dim
].end
- ls
[dim
].start
) * ls
[dim
].step
< 0)
1818 || (ls
[dim
].step
== 0))
1820 st_sprintf (parse_err_msg
, "Bad range in index %d", dim
+ 1);
1824 /* Initialise the loop index counter. */
1825 ls
[dim
].idx
= ls
[dim
].start
;
1835 static namelist_info
*
1836 find_nml_node (st_parameter_dt
*dtp
, char * var_name
)
1838 namelist_info
* t
= dtp
->u
.p
.ionml
;
1841 if (strcmp (var_name
, t
->var_name
) == 0)
1851 /* Visits all the components of a derived type that have
1852 not explicitly been identified in the namelist input.
1853 touched is set and the loop specification initialised
1854 to default values */
1857 nml_touch_nodes (namelist_info
* nl
)
1859 index_type len
= strlen (nl
->var_name
) + 1;
1861 char * ext_name
= (char*)get_mem (len
+ 1);
1862 strcpy (ext_name
, nl
->var_name
);
1863 strcat (ext_name
, "%");
1864 for (nl
= nl
->next
; nl
; nl
= nl
->next
)
1866 if (strncmp (nl
->var_name
, ext_name
, len
) == 0)
1869 for (dim
=0; dim
< nl
->var_rank
; dim
++)
1871 nl
->ls
[dim
].step
= 1;
1872 nl
->ls
[dim
].end
= nl
->dim
[dim
].ubound
;
1873 nl
->ls
[dim
].start
= nl
->dim
[dim
].lbound
;
1874 nl
->ls
[dim
].idx
= nl
->ls
[dim
].start
;
1880 free_mem (ext_name
);
1884 /* Resets touched for the entire list of nml_nodes, ready for a
1888 nml_untouch_nodes (st_parameter_dt
*dtp
)
1891 for (t
= dtp
->u
.p
.ionml
; t
; t
= t
->next
)
1896 /* Attempts to input name to namelist name. Returns
1897 dtp->u.p.nml_read_error = 1 on no match. */
1900 nml_match_name (st_parameter_dt
*dtp
, const char *name
, index_type len
)
1904 dtp
->u
.p
.nml_read_error
= 0;
1905 for (i
= 0; i
< len
; i
++)
1907 c
= next_char (dtp
);
1908 if (tolower (c
) != tolower (name
[i
]))
1910 dtp
->u
.p
.nml_read_error
= 1;
1916 /* If the namelist read is from stdin, output the current state of the
1917 namelist to stdout. This is used to implement the non-standard query
1918 features, ? and =?. If c == '=' the full namelist is printed. Otherwise
1919 the names alone are printed. */
1922 nml_query (st_parameter_dt
*dtp
, char c
)
1924 gfc_unit
* temp_unit
;
1929 if (dtp
->u
.p
.current_unit
->unit_number
!= options
.stdin_unit
)
1932 /* Store the current unit and transfer to stdout. */
1934 temp_unit
= dtp
->u
.p
.current_unit
;
1935 dtp
->u
.p
.current_unit
= find_unit (options
.stdout_unit
);
1937 if (dtp
->u
.p
.current_unit
)
1939 dtp
->u
.p
.mode
= WRITING
;
1940 next_record (dtp
, 0);
1942 /* Write the namelist in its entirety. */
1945 namelist_write (dtp
);
1947 /* Or write the list of names. */
1952 /* "&namelist_name\n" */
1954 len
= dtp
->namelist_name_len
;
1956 p
= write_block (dtp
, len
+ 3);
1958 p
= write_block (dtp
, len
+ 2);
1963 memcpy ((char*)(p
+ 1), dtp
->namelist_name
, len
);
1965 memcpy ((char*)(p
+ len
+ 1), "\r\n", 2);
1967 memcpy ((char*)(p
+ len
+ 1), "\n", 1);
1969 for (nl
= dtp
->u
.p
.ionml
; nl
; nl
= nl
->next
)
1974 len
= strlen (nl
->var_name
);
1976 p
= write_block (dtp
, len
+ 3);
1978 p
= write_block (dtp
, len
+ 2);
1983 memcpy ((char*)(p
+ 1), nl
->var_name
, len
);
1985 memcpy ((char*)(p
+ len
+ 1), "\r\n", 2);
1987 memcpy ((char*)(p
+ len
+ 1), "\n", 1);
1994 p
= write_block (dtp
, 6);
1996 p
= write_block (dtp
, 5);
2001 memcpy (p
, "&end\r\n", 6);
2003 memcpy (p
, "&end\n", 5);
2007 /* Flush the stream to force immediate output. */
2009 flush (dtp
->u
.p
.current_unit
->s
);
2010 unlock_unit (dtp
->u
.p
.current_unit
);
2015 /* Restore the current unit. */
2017 dtp
->u
.p
.current_unit
= temp_unit
;
2018 dtp
->u
.p
.mode
= READING
;
2022 /* Reads and stores the input for the namelist object nl. For an array,
2023 the function loops over the ranges defined by the loop specification.
2024 This default to all the data or to the specification from a qualifier.
2025 nml_read_obj recursively calls itself to read derived types. It visits
2026 all its own components but only reads data for those that were touched
2027 when the name was parsed. If a read error is encountered, an attempt is
2028 made to return to read a new object name because the standard allows too
2029 little data to be available. On the other hand, too much data is an
2033 nml_read_obj (st_parameter_dt
*dtp
, namelist_info
* nl
, index_type offset
,
2034 namelist_info
**pprev_nl
, char *nml_err_msg
,
2035 index_type clow
, index_type chigh
)
2038 namelist_info
* cmp
;
2045 index_type obj_name_len
;
2048 /* This object not touched in name parsing. */
2053 dtp
->u
.p
.repeat_count
= 0;
2060 case GFC_DTYPE_INTEGER
:
2061 case GFC_DTYPE_LOGICAL
:
2065 case GFC_DTYPE_REAL
:
2066 dlen
= size_from_real_kind (len
);
2069 case GFC_DTYPE_COMPLEX
:
2070 dlen
= size_from_complex_kind (len
);
2073 case GFC_DTYPE_CHARACTER
:
2074 dlen
= chigh
? (chigh
- clow
+ 1) : nl
->string_length
;
2084 /* Update the pointer to the data, using the current index vector */
2086 pdata
= (void*)(nl
->mem_pos
+ offset
);
2087 for (dim
= 0; dim
< nl
->var_rank
; dim
++)
2088 pdata
= (void*)(pdata
+ (nl
->ls
[dim
].idx
- nl
->dim
[dim
].lbound
) *
2089 nl
->dim
[dim
].stride
* nl
->size
);
2091 /* Reset the error flag and try to read next value, if
2092 dtp->u.p.repeat_count=0 */
2094 dtp
->u
.p
.nml_read_error
= 0;
2096 if (--dtp
->u
.p
.repeat_count
<= 0)
2098 if (dtp
->u
.p
.input_complete
)
2100 if (dtp
->u
.p
.at_eol
)
2101 finish_separator (dtp
);
2102 if (dtp
->u
.p
.input_complete
)
2105 /* GFC_TYPE_UNKNOWN through for nulls and is detected
2106 after the switch block. */
2108 dtp
->u
.p
.saved_type
= GFC_DTYPE_UNKNOWN
;
2113 case GFC_DTYPE_INTEGER
:
2114 read_integer (dtp
, len
);
2117 case GFC_DTYPE_LOGICAL
:
2118 read_logical (dtp
, len
);
2121 case GFC_DTYPE_CHARACTER
:
2122 read_character (dtp
, len
);
2125 case GFC_DTYPE_REAL
:
2126 read_real (dtp
, len
);
2129 case GFC_DTYPE_COMPLEX
:
2130 read_complex (dtp
, len
, dlen
);
2133 case GFC_DTYPE_DERIVED
:
2134 obj_name_len
= strlen (nl
->var_name
) + 1;
2135 obj_name
= get_mem (obj_name_len
+1);
2136 strcpy (obj_name
, nl
->var_name
);
2137 strcat (obj_name
, "%");
2139 /* If reading a derived type, disable the expanded read warning
2140 since a single object can have multiple reads. */
2141 dtp
->u
.p
.expanded_read
= 0;
2143 /* Now loop over the components. Update the component pointer
2144 with the return value from nml_write_obj. This loop jumps
2145 past nested derived types by testing if the potential
2146 component name contains '%'. */
2148 for (cmp
= nl
->next
;
2150 !strncmp (cmp
->var_name
, obj_name
, obj_name_len
) &&
2151 !strchr (cmp
->var_name
+ obj_name_len
, '%');
2155 if (nml_read_obj (dtp
, cmp
, (index_type
)(pdata
- nl
->mem_pos
),
2156 pprev_nl
, nml_err_msg
, clow
, chigh
)
2159 free_mem (obj_name
);
2163 if (dtp
->u
.p
.input_complete
)
2165 free_mem (obj_name
);
2170 free_mem (obj_name
);
2174 st_sprintf (nml_err_msg
, "Bad type for namelist object %s",
2176 internal_error (&dtp
->common
, nml_err_msg
);
2181 /* The standard permits array data to stop short of the number of
2182 elements specified in the loop specification. In this case, we
2183 should be here with dtp->u.p.nml_read_error != 0. Control returns to
2184 nml_get_obj_data and an attempt is made to read object name. */
2187 if (dtp
->u
.p
.nml_read_error
)
2189 dtp
->u
.p
.expanded_read
= 0;
2193 if (dtp
->u
.p
.saved_type
== GFC_DTYPE_UNKNOWN
)
2195 dtp
->u
.p
.expanded_read
= 0;
2199 /* Note the switch from GFC_DTYPE_type to BT_type at this point.
2200 This comes about because the read functions return BT_types. */
2202 switch (dtp
->u
.p
.saved_type
)
2209 memcpy (pdata
, dtp
->u
.p
.value
, dlen
);
2213 m
= (dlen
< dtp
->u
.p
.saved_used
) ? dlen
: dtp
->u
.p
.saved_used
;
2214 pdata
= (void*)( pdata
+ clow
- 1 );
2215 memcpy (pdata
, dtp
->u
.p
.saved_string
, m
);
2217 memset ((void*)( pdata
+ m
), ' ', dlen
- m
);
2224 /* Warn if a non-standard expanded read occurs. A single read of a
2225 single object is acceptable. If a second read occurs, issue a warning
2226 and set the flag to zero to prevent further warnings. */
2227 if (dtp
->u
.p
.expanded_read
== 2)
2229 notify_std (&dtp
->common
, GFC_STD_GNU
, "Non-standard expanded namelist read.");
2230 dtp
->u
.p
.expanded_read
= 0;
2233 /* If the expanded read warning flag is set, increment it,
2234 indicating that a single read has occurred. */
2235 if (dtp
->u
.p
.expanded_read
>= 1)
2236 dtp
->u
.p
.expanded_read
++;
2238 /* Break out of loop if scalar. */
2242 /* Now increment the index vector. */
2247 for (dim
= 0; dim
< nl
->var_rank
; dim
++)
2249 nl
->ls
[dim
].idx
+= nml_carry
* nl
->ls
[dim
].step
;
2251 if (((nl
->ls
[dim
].step
> 0) && (nl
->ls
[dim
].idx
> nl
->ls
[dim
].end
))
2253 ((nl
->ls
[dim
].step
< 0) && (nl
->ls
[dim
].idx
< nl
->ls
[dim
].end
)))
2255 nl
->ls
[dim
].idx
= nl
->ls
[dim
].start
;
2259 } while (!nml_carry
);
2261 if (dtp
->u
.p
.repeat_count
> 1)
2263 st_sprintf (nml_err_msg
, "Repeat count too large for namelist object %s" ,
2274 /* Parses the object name, including array and substring qualifiers. It
2275 iterates over derived type components, touching those components and
2276 setting their loop specifications, if there is a qualifier. If the
2277 object is itself a derived type, its components and subcomponents are
2278 touched. nml_read_obj is called at the end and this reads the data in
2279 the manner specified by the object name. */
2282 nml_get_obj_data (st_parameter_dt
*dtp
, namelist_info
**pprev_nl
,
2287 namelist_info
* first_nl
= NULL
;
2288 namelist_info
* root_nl
= NULL
;
2291 char parse_err_msg
[30];
2292 index_type clow
, chigh
;
2294 /* Look for end of input or object name. If '?' or '=?' are encountered
2295 in stdin, print the node names or the namelist to stdout. */
2297 eat_separator (dtp
);
2298 if (dtp
->u
.p
.input_complete
)
2301 if (dtp
->u
.p
.at_eol
)
2302 finish_separator (dtp
);
2303 if (dtp
->u
.p
.input_complete
)
2306 c
= next_char (dtp
);
2310 c
= next_char (dtp
);
2313 st_sprintf (nml_err_msg
, "namelist read: misplaced = sign");
2316 nml_query (dtp
, '=');
2320 nml_query (dtp
, '?');
2325 nml_match_name (dtp
, "end", 3);
2326 if (dtp
->u
.p
.nml_read_error
)
2328 st_sprintf (nml_err_msg
, "namelist not terminated with / or &end");
2332 dtp
->u
.p
.input_complete
= 1;
2339 /* Untouch all nodes of the namelist and reset the flag that is set for
2340 derived type components. */
2342 nml_untouch_nodes (dtp
);
2345 /* Get the object name - should '!' and '\n' be permitted separators? */
2353 push_char (dtp
, tolower(c
));
2354 c
= next_char (dtp
);
2355 } while (!( c
=='=' || c
==' ' || c
=='\t' || c
=='(' || c
=='%' ));
2357 unget_char (dtp
, c
);
2359 /* Check that the name is in the namelist and get pointer to object.
2360 Three error conditions exist: (i) An attempt is being made to
2361 identify a non-existent object, following a failed data read or
2362 (ii) The object name does not exist or (iii) Too many data items
2363 are present for an object. (iii) gives the same error message
2366 push_char (dtp
, '\0');
2370 size_t var_len
= strlen (root_nl
->var_name
);
2372 = dtp
->u
.p
.saved_string
? strlen (dtp
->u
.p
.saved_string
) : 0;
2373 char ext_name
[var_len
+ saved_len
+ 1];
2375 memcpy (ext_name
, root_nl
->var_name
, var_len
);
2376 if (dtp
->u
.p
.saved_string
)
2377 memcpy (ext_name
+ var_len
, dtp
->u
.p
.saved_string
, saved_len
);
2378 ext_name
[var_len
+ saved_len
] = '\0';
2379 nl
= find_nml_node (dtp
, ext_name
);
2382 nl
= find_nml_node (dtp
, dtp
->u
.p
.saved_string
);
2386 if (dtp
->u
.p
.nml_read_error
&& *pprev_nl
)
2387 st_sprintf (nml_err_msg
, "Bad data for namelist object %s",
2388 (*pprev_nl
)->var_name
);
2391 st_sprintf (nml_err_msg
, "Cannot match namelist object name %s",
2392 dtp
->u
.p
.saved_string
);
2397 /* Get the length, data length, base pointer and rank of the variable.
2398 Set the default loop specification first. */
2400 for (dim
=0; dim
< nl
->var_rank
; dim
++)
2402 nl
->ls
[dim
].step
= 1;
2403 nl
->ls
[dim
].end
= nl
->dim
[dim
].ubound
;
2404 nl
->ls
[dim
].start
= nl
->dim
[dim
].lbound
;
2405 nl
->ls
[dim
].idx
= nl
->ls
[dim
].start
;
2408 /* Check to see if there is a qualifier: if so, parse it.*/
2410 if (c
== '(' && nl
->var_rank
)
2412 if (nml_parse_qualifier (dtp
, nl
->dim
, nl
->ls
, nl
->var_rank
,
2413 parse_err_msg
) == FAILURE
)
2415 st_sprintf (nml_err_msg
, "%s for namelist variable %s",
2416 parse_err_msg
, nl
->var_name
);
2419 c
= next_char (dtp
);
2420 unget_char (dtp
, c
);
2423 /* Now parse a derived type component. The root namelist_info address
2424 is backed up, as is the previous component level. The component flag
2425 is set and the iteration is made by jumping back to get_name. */
2430 if (nl
->type
!= GFC_DTYPE_DERIVED
)
2432 st_sprintf (nml_err_msg
, "Attempt to get derived component for %s",
2437 if (!component_flag
)
2442 c
= next_char (dtp
);
2447 /* Parse a character qualifier, if present. chigh = 0 is a default
2448 that signals that the string length = string_length. */
2453 if (c
== '(' && nl
->type
== GFC_DTYPE_CHARACTER
)
2455 descriptor_dimension chd
[1] = { {1, clow
, nl
->string_length
} };
2456 array_loop_spec ind
[1] = { {1, clow
, nl
->string_length
, 1} };
2458 if (nml_parse_qualifier (dtp
, chd
, ind
, 1, parse_err_msg
) == FAILURE
)
2460 st_sprintf (nml_err_msg
, "%s for namelist variable %s",
2461 parse_err_msg
, nl
->var_name
);
2465 clow
= ind
[0].start
;
2468 if (ind
[0].step
!= 1)
2470 st_sprintf (nml_err_msg
,
2471 "Bad step in substring for namelist object %s",
2476 c
= next_char (dtp
);
2477 unget_char (dtp
, c
);
2480 /* If a derived type touch its components and restore the root
2481 namelist_info if we have parsed a qualified derived type
2484 if (nl
->type
== GFC_DTYPE_DERIVED
)
2485 nml_touch_nodes (nl
);
2489 /*make sure no extraneous qualifiers are there.*/
2493 st_sprintf (nml_err_msg
, "Qualifier for a scalar or non-character"
2494 " namelist object %s", nl
->var_name
);
2498 /* According to the standard, an equal sign MUST follow an object name. The
2499 following is possibly lax - it allows comments, blank lines and so on to
2500 intervene. eat_spaces (dtp); c = next_char (dtp); would be compliant*/
2504 eat_separator (dtp
);
2505 if (dtp
->u
.p
.input_complete
)
2508 if (dtp
->u
.p
.at_eol
)
2509 finish_separator (dtp
);
2510 if (dtp
->u
.p
.input_complete
)
2513 c
= next_char (dtp
);
2517 st_sprintf (nml_err_msg
, "Equal sign must follow namelist object name %s",
2522 if (nml_read_obj (dtp
, nl
, 0, pprev_nl
, nml_err_msg
, clow
, chigh
) == FAILURE
)
2532 /* Entry point for namelist input. Goes through input until namelist name
2533 is matched. Then cycles through nml_get_obj_data until the input is
2534 completed or there is an error. */
2537 namelist_read (st_parameter_dt
*dtp
)
2541 char nml_err_msg
[100];
2542 /* Pointer to the previously read object, in case attempt is made to read
2543 new object name. Should this fail, error message can give previous
2545 namelist_info
*prev_nl
= NULL
;
2547 dtp
->u
.p
.namelist_mode
= 1;
2548 dtp
->u
.p
.input_complete
= 0;
2549 dtp
->u
.p
.expanded_read
= 0;
2551 dtp
->u
.p
.eof_jump
= &eof_jump
;
2552 if (setjmp (eof_jump
))
2554 dtp
->u
.p
.eof_jump
= NULL
;
2555 generate_error (&dtp
->common
, ERROR_END
, NULL
);
2559 /* Look for &namelist_name . Skip all characters, testing for $nmlname.
2560 Exit on success or EOF. If '?' or '=?' encountered in stdin, print
2561 node names or namelist on stdout. */
2564 switch (c
= next_char (dtp
))
2571 c
= next_char (dtp
);
2573 nml_query (dtp
, '=');
2575 unget_char (dtp
, c
);
2579 nml_query (dtp
, '?');
2585 /* Match the name of the namelist. */
2587 nml_match_name (dtp
, dtp
->namelist_name
, dtp
->namelist_name_len
);
2589 if (dtp
->u
.p
.nml_read_error
)
2592 /* Ready to read namelist objects. If there is an error in input
2593 from stdin, output the error message and continue. */
2595 while (!dtp
->u
.p
.input_complete
)
2597 if (nml_get_obj_data (dtp
, &prev_nl
, nml_err_msg
) == FAILURE
)
2601 if (dtp
->u
.p
.current_unit
->unit_number
!= options
.stdin_unit
)
2604 u
= find_unit (options
.stderr_unit
);
2605 st_printf ("%s\n", nml_err_msg
);
2615 dtp
->u
.p
.eof_jump
= NULL
;
2620 /* All namelist error calls return from here */
2624 dtp
->u
.p
.eof_jump
= NULL
;
2627 generate_error (&dtp
->common
, ERROR_READ_VALUE
, nml_err_msg
);