typedef struct stream
{
- ssize_t (*read) (struct stream *, void *, ssize_t);
- ssize_t (*write) (struct stream *, const void *, ssize_t);
- off_t (*seek) (struct stream *, off_t, int);
- off_t (*tell) (struct stream *);
- int (*truncate) (struct stream *, off_t);
- int (*flush) (struct stream *);
- int (*close) (struct stream *);
+ char *(*alloc_w_at) (struct stream *, int *);
+ try (*sfree) (struct stream *);
+ try (*close) (struct stream *);
+ try (*seek) (struct stream *, gfc_offset);
+ try (*trunc) (struct stream *);
+ int (*read) (struct stream *, void *, size_t *);
+ int (*write) (struct stream *, const void *, size_t *);
+ try (*set) (struct stream *, int, size_t);
}
stream;
-/* Inline functions for doing file I/O given a stream. */
-static inline ssize_t
-sread (stream * s, void * buf, ssize_t nbyte)
-{
- return s->read (s, buf, nbyte);
-}
+typedef enum
+{ SYNC_BUFFERED, SYNC_UNBUFFERED, ASYNC }
+io_mode;
-static inline ssize_t
-swrite (stream * s, const void * buf, ssize_t nbyte)
-{
- return s->write (s, buf, nbyte);
-}
+/* Macros for doing file I/O given a stream. */
-static inline off_t
-sseek (stream * s, off_t offset, int whence)
-{
- return s->seek (s, offset, whence);
-}
+#define sfree(s) ((s)->sfree)(s)
+#define sclose(s) ((s)->close)(s)
-static inline off_t
-stell (stream * s)
-{
- return s->tell (s);
-}
+#define salloc_w(s, len) ((s)->alloc_w_at)(s, len)
-static inline int
-struncate (stream * s, off_t length)
-{
- return s->truncate (s, length);
-}
-
-static inline int
-sflush (stream * s)
-{
- return s->flush (s);
-}
-
-static inline int
-sclose (stream * s)
-{
- return s->close (s);
-}
+#define sseek(s, pos) ((s)->seek)(s, pos)
+#define struncate(s) ((s)->trunc)(s)
+#define sread(s, buf, nbytes) ((s)->read)(s, buf, nbytes)
+#define swrite(s, buf, nbytes) ((s)->write)(s, buf, nbytes)
+#define sset(s, c, n) ((s)->set)(s, c, n)
/* Macros for testing what kinds of I/O we are doing. */
typedef struct fbuf
{
char *buf; /* Start of buffer. */
- int len; /* Length of buffer. */
- int act; /* Active bytes in buffer. */
- int pos; /* Current position in buffer. */
+ size_t len; /* Length of buffer. */
+ size_t act; /* Active bytes in buffer. */
+ size_t flushed; /* Flushed bytes from beginning of buffer. */
+ size_t pos; /* Current position in buffer. */
}
fbuf;
extern stream *open_internal (char *, int, gfc_offset);
internal_proto(open_internal);
-extern char * mem_alloc_w (stream *, int *);
-internal_proto(mem_alloc_w);
-
-extern char * mem_alloc_r (stream *, int *);
-internal_proto(mem_alloc_w);
-
extern stream *input_stream (void);
internal_proto(input_stream);
extern gfc_unit *find_file (const char *file, gfc_charlen_type file_len);
internal_proto(find_file);
+extern int stream_at_bof (stream *);
+internal_proto(stream_at_bof);
+
+extern int stream_at_eof (stream *);
+internal_proto(stream_at_eof);
+
extern int delete_file (gfc_unit *);
internal_proto(delete_file);
extern gfc_offset file_length (stream *);
internal_proto(file_length);
+extern gfc_offset file_position (stream *);
+internal_proto(file_position);
+
extern int is_seekable (stream *);
internal_proto(is_seekable);
extern void empty_internal_buffer(stream *);
internal_proto(empty_internal_buffer);
+extern try flush (stream *);
+internal_proto(flush);
+
extern int stream_isatty (stream *);
internal_proto(stream_isatty);
extern char * stream_ttyname (stream *);
internal_proto(stream_ttyname);
+extern gfc_offset stream_offset (stream *s);
+internal_proto(stream_offset);
+
extern int unpack_filename (char *, const char *, int);
internal_proto(unpack_filename);
extern void finish_last_advance_record (gfc_unit *u);
internal_proto (finish_last_advance_record);
-extern int unit_truncate (gfc_unit *, gfc_offset, st_parameter_common *);
-internal_proto (unit_truncate);
-
/* open.c */
extern gfc_unit *new_unit (st_parameter_open *, gfc_unit *, unit_flags *);
extern const char *type_name (bt);
internal_proto(type_name);
-extern void * read_block_form (st_parameter_dt *, int *);
+extern try read_block_form (st_parameter_dt *, void *, size_t *);
internal_proto(read_block_form);
extern char *read_sf (st_parameter_dt *, int *, int);
extern void st_wait (st_parameter_wait *);
export_proto(st_wait);
-extern void hit_eof (st_parameter_dt *);
-internal_proto(hit_eof);
-
/* read.c */
extern void set_integer (void *, GFC_INTEGER_LARGEST, int);
internal_proto(size_from_complex_kind);
/* fbuf.c */
-extern void fbuf_init (gfc_unit *, int);
+extern void fbuf_init (gfc_unit *, size_t);
internal_proto(fbuf_init);
extern void fbuf_destroy (gfc_unit *);
internal_proto(fbuf_destroy);
-extern int fbuf_reset (gfc_unit *);
+extern void fbuf_reset (gfc_unit *);
internal_proto(fbuf_reset);
-extern char * fbuf_alloc (gfc_unit *, int);
+extern char * fbuf_alloc (gfc_unit *, size_t);
internal_proto(fbuf_alloc);
-extern int fbuf_flush (gfc_unit *, unit_mode);
+extern int fbuf_flush (gfc_unit *, int);
internal_proto(fbuf_flush);
-extern int fbuf_seek (gfc_unit *, int, int);
+extern int fbuf_seek (gfc_unit *, gfc_offset);
internal_proto(fbuf_seek);
-extern char * fbuf_read (gfc_unit *, int *);
-internal_proto(fbuf_read);
-
-/* Never call this function, only use fbuf_getc(). */
-extern int fbuf_getc_refill (gfc_unit *);
-internal_proto(fbuf_getc_refill);
-
-static inline int
-fbuf_getc (gfc_unit * u)
-{
- if (u->fbuf->pos < u->fbuf->act)
- return (unsigned char) u->fbuf->buf[u->fbuf->pos++];
- return fbuf_getc_refill (u);
-}
-
/* lock.c */
extern void free_ionml (st_parameter_dt *);
internal_proto(free_ionml);
#include <string.h>
#include <assert.h>
#include <stdlib.h>
-#include <errno.h>
/* Calling conventions: Data transfer statements are unlike other
heap. Hopefully this won't happen very often. */
char *
-read_sf (st_parameter_dt *dtp, int * length, int no_error)
+read_sf (st_parameter_dt *dtp, int *length, int no_error)
{
- static char *empty_string[0];
char *base, *p, q;
- int n, lorig, memread, seen_comma;
+ int n, crlf;
+ gfc_offset pos;
+ size_t readlen;
- /* If we hit EOF previously with the no_error flag set (i.e. X, T,
- TR edit descriptors), and we now try to read again, this time
- without setting no_error. */
- if (!no_error && dtp->u.p.at_eof)
- {
- *length = 0;
- hit_eof (dtp);
- return NULL;
- }
+ if (*length > SCRATCH_SIZE)
+ dtp->u.p.line_buffer = get_mem (*length);
+ p = base = dtp->u.p.line_buffer;
/* If we have seen an eor previously, return a length of 0. The
caller is responsible for correctly padding the input field. */
if (dtp->u.p.sf_seen_eor)
{
*length = 0;
- /* Just return something that isn't a NULL pointer, otherwise the
- caller thinks an error occured. */
- return (char*) empty_string;
+ return base;
}
if (is_internal_unit (dtp))
{
- memread = *length;
- base = mem_alloc_r (dtp->u.p.current_unit->s, length);
- if (unlikely (memread > *length))
+ readlen = *length;
+ if (unlikely (sread (dtp->u.p.current_unit->s, p, &readlen) != 0
+ || readlen < (size_t) *length))
{
- hit_eof (dtp);
+ generate_error (&dtp->common, LIBERROR_END, NULL);
return NULL;
}
- n = *length;
+
goto done;
}
- n = seen_comma = 0;
+ readlen = 1;
+ n = 0;
- /* Read data into format buffer and scan through it. */
- lorig = *length;
- base = p = fbuf_read (dtp->u.p.current_unit, length);
- if (base == NULL)
- return NULL;
-
- while (n < *length)
+ do
{
- q = *p;
+ if (unlikely (sread (dtp->u.p.current_unit->s, &q, &readlen) != 0))
+ {
+ generate_error (&dtp->common, LIBERROR_END, NULL);
+ return NULL;
+ }
- if (q == '\n' || q == '\r')
+ /* If we have a line without a terminating \n, drop through to
+ EOR below. */
+ if (readlen < 1 && n == 0)
+ {
+ if (likely (no_error))
+ break;
+ generate_error (&dtp->common, LIBERROR_END, NULL);
+ return NULL;
+ }
+
+ if (readlen < 1 || q == '\n' || q == '\r')
{
/* Unexpected end of line. */
if (dtp->u.p.advance_status == ADVANCE_NO || dtp->u.p.seen_dollar)
dtp->u.p.eor_condition = 1;
+ crlf = 0;
/* If we encounter a CR, it might be a CRLF. */
if (q == '\r') /* Probably a CRLF */
{
- if (n < *length && *(p + 1) == '\n')
- dtp->u.p.sf_seen_eor = 2;
+ readlen = 1;
+ pos = stream_offset (dtp->u.p.current_unit->s);
+ if (unlikely (sread (dtp->u.p.current_unit->s, &q, &readlen)
+ != 0))
+ {
+ generate_error (&dtp->common, LIBERROR_END, NULL);
+ return NULL;
+ }
+ if (q != '\n' && readlen == 1) /* Not a CRLF after all. */
+ sseek (dtp->u.p.current_unit->s, pos);
+ else
+ crlf = 1;
}
- else
- dtp->u.p.sf_seen_eor = 1;
/* Without padding, terminate the I/O statement without assigning
the value. With padding, the value still needs to be assigned,
}
*length = n;
+ dtp->u.p.sf_seen_eor = (crlf ? 2 : 1);
break;
}
/* Short circuit the read if a comma is found during numeric input.
if (q == ',')
if (dtp->u.p.sf_read_comma == 1)
{
- seen_comma = 1;
notify_std (&dtp->common, GFC_STD_GNU,
"Comma in formatted numeric read.");
*length = n;
}
n++;
- p++;
- }
-
- fbuf_seek (dtp->u.p.current_unit, n + dtp->u.p.sf_seen_eor + seen_comma,
- SEEK_CUR);
-
- /* A short read implies we hit EOF, unless we hit EOR, a comma, or
- some other stuff. Set the relevant flags. */
- if (lorig > *length && !dtp->u.p.sf_seen_eor && !seen_comma)
- {
- if (no_error)
- dtp->u.p.at_eof = 1;
- else
- {
- hit_eof (dtp);
- return NULL;
- }
+ *p++ = q;
+ dtp->u.p.sf_seen_eor = 0;
}
+ while (n < *length);
done:
-
- dtp->u.p.current_unit->bytes_left -= n;
+ dtp->u.p.current_unit->bytes_left -= *length;
if ((dtp->common.flags & IOPARM_DT_HAS_SIZE) != 0)
- dtp->u.p.size_used += (GFC_IO_INT) n;
+ dtp->u.p.size_used += (GFC_IO_INT) *length;
return base;
}
opened with PAD=YES. The caller must assume tailing spaces for
short reads. */
-void *
-read_block_form (st_parameter_dt *dtp, int * nbytes)
+try
+read_block_form (st_parameter_dt *dtp, void *buf, size_t *nbytes)
{
char *source;
- int norig;
+ size_t nread;
+ int nb;
if (!is_stream_io (dtp))
{
{
/* Not enough data left. */
generate_error (&dtp->common, LIBERROR_EOR, NULL);
- return NULL;
+ return FAILURE;
}
}
if (unlikely (dtp->u.p.current_unit->bytes_left == 0))
{
- hit_eof (dtp);
- return NULL;
+ dtp->u.p.current_unit->endfile = AT_ENDFILE;
+ generate_error (&dtp->common, LIBERROR_END, NULL);
+ return FAILURE;
}
*nbytes = dtp->u.p.current_unit->bytes_left;
(dtp->u.p.current_unit->flags.access == ACCESS_SEQUENTIAL ||
dtp->u.p.current_unit->flags.access == ACCESS_STREAM))
{
- source = read_sf (dtp, nbytes, 0);
+ nb = *nbytes;
+ source = read_sf (dtp, &nb, 0);
+ *nbytes = nb;
dtp->u.p.current_unit->strm_pos +=
(gfc_offset) (*nbytes + dtp->u.p.sf_seen_eor);
- return source;
+ if (source == NULL)
+ return FAILURE;
+ memcpy (buf, source, *nbytes);
+ return SUCCESS;
}
-
- /* If we reach here, we can assume it's direct access. */
-
dtp->u.p.current_unit->bytes_left -= (gfc_offset) *nbytes;
- norig = *nbytes;
- source = fbuf_read (dtp->u.p.current_unit, nbytes);
- fbuf_seek (dtp->u.p.current_unit, *nbytes, SEEK_CUR);
+ nread = *nbytes;
+ if (unlikely (sread (dtp->u.p.current_unit->s, buf, &nread) != 0))
+ {
+ generate_error (&dtp->common, LIBERROR_OS, NULL);
+ return FAILURE;
+ }
if ((dtp->common.flags & IOPARM_DT_HAS_SIZE) != 0)
- dtp->u.p.size_used += (GFC_IO_INT) *nbytes;
+ dtp->u.p.size_used += (GFC_IO_INT) nread;
- if (norig != *nbytes)
- {
- /* Short read, this shouldn't happen. */
- if (!dtp->u.p.current_unit->pad_status == PAD_YES)
+ if (nread != *nbytes)
+ { /* Short read, this shouldn't happen. */
+ if (likely (dtp->u.p.current_unit->pad_status == PAD_YES))
+ *nbytes = nread;
+ else
{
generate_error (&dtp->common, LIBERROR_EOR, NULL);
source = NULL;
}
}
- dtp->u.p.current_unit->strm_pos += (gfc_offset) *nbytes;
+ dtp->u.p.current_unit->strm_pos += (gfc_offset) nread;
- return source;
+ return SUCCESS;
}
static void
read_block_direct (st_parameter_dt *dtp, void *buf, size_t *nbytes)
{
- ssize_t to_read_record;
- ssize_t have_read_record;
- ssize_t to_read_subrecord;
- ssize_t have_read_subrecord;
+ size_t to_read_record;
+ size_t have_read_record;
+ size_t to_read_subrecord;
+ size_t have_read_subrecord;
int short_record;
if (is_stream_io (dtp))
{
to_read_record = *nbytes;
- have_read_record = sread (dtp->u.p.current_unit->s, buf,
- to_read_record);
- if (unlikely (have_read_record < 0))
+ have_read_record = to_read_record;
+ if (unlikely (sread (dtp->u.p.current_unit->s, buf, &have_read_record)
+ != 0))
{
generate_error (&dtp->common, LIBERROR_OS, NULL);
return;
{
/* Short read, e.g. if we hit EOF. For stream files,
we have to set the end-of-file condition. */
- hit_eof (dtp);
+ generate_error (&dtp->common, LIBERROR_END, NULL);
return;
}
return;
dtp->u.p.current_unit->bytes_left -= to_read_record;
- to_read_record = sread (dtp->u.p.current_unit->s, buf, to_read_record);
- if (unlikely (to_read_record < 0))
+ if (unlikely (sread (dtp->u.p.current_unit->s, buf, &to_read_record)
+ != 0))
{
generate_error (&dtp->common, LIBERROR_OS, NULL);
return;
}
- if (to_read_record != (ssize_t) *nbytes)
+ if (to_read_record != *nbytes)
{
/* Short read, e.g. if we hit EOF. Apparently, we read
more than was written to the last record. */
until the request has been fulfilled or the record has run out
of continuation subrecords. */
+ if (unlikely (dtp->u.p.current_unit->endfile == AT_ENDFILE))
+ {
+ generate_error (&dtp->common, LIBERROR_END, NULL);
+ return;
+ }
+
/* Check whether we exceed the total record length. */
if (dtp->u.p.current_unit->flags.has_recl
&& (*nbytes > (size_t) dtp->u.p.current_unit->bytes_left))
{
- to_read_record = (ssize_t) dtp->u.p.current_unit->bytes_left;
+ to_read_record = (size_t) dtp->u.p.current_unit->bytes_left;
short_record = 1;
}
else
if (dtp->u.p.current_unit->bytes_left_subrecord
< (gfc_offset) to_read_record)
{
- to_read_subrecord = (ssize_t) dtp->u.p.current_unit->bytes_left_subrecord;
+ to_read_subrecord = (size_t) dtp->u.p.current_unit->bytes_left_subrecord;
to_read_record -= to_read_subrecord;
}
else
dtp->u.p.current_unit->bytes_left_subrecord -= to_read_subrecord;
- have_read_subrecord = sread (dtp->u.p.current_unit->s,
- buf + have_read_record, to_read_subrecord);
- if (unlikely (have_read_subrecord) < 0)
+ have_read_subrecord = to_read_subrecord;
+ if (unlikely (sread (dtp->u.p.current_unit->s, buf + have_read_record,
+ &have_read_subrecord) != 0))
{
generate_error (&dtp->common, LIBERROR_OS, NULL);
return;
if (is_internal_unit (dtp))
{
- dest = mem_alloc_w (dtp->u.p.current_unit->s, &length);
+ dest = salloc_w (dtp->u.p.current_unit->s, &length);
if (dest == NULL)
{
write_buf (st_parameter_dt *dtp, void *buf, size_t nbytes)
{
- ssize_t have_written;
- ssize_t to_write_subrecord;
+ size_t have_written, to_write_subrecord;
int short_record;
/* Stream I/O. */
if (is_stream_io (dtp))
{
- have_written = swrite (dtp->u.p.current_unit->s, buf, nbytes);
- if (unlikely (have_written < 0))
+ if (unlikely (swrite (dtp->u.p.current_unit->s, buf, &nbytes) != 0))
{
generate_error (&dtp->common, LIBERROR_OS, NULL);
return FAILURE;
}
- dtp->u.p.current_unit->strm_pos += (gfc_offset) have_written;
+ dtp->u.p.current_unit->strm_pos += (gfc_offset) nbytes;
return SUCCESS;
}
if (buf == NULL && nbytes == 0)
return SUCCESS;
- have_written = swrite (dtp->u.p.current_unit->s, buf, nbytes);
- if (unlikely (have_written < 0))
+ if (unlikely (swrite (dtp->u.p.current_unit->s, buf, &nbytes) != 0))
{
generate_error (&dtp->common, LIBERROR_OS, NULL);
return FAILURE;
}
- dtp->u.p.current_unit->strm_pos += (gfc_offset) have_written;
- dtp->u.p.current_unit->bytes_left -= (gfc_offset) have_written;
+ dtp->u.p.current_unit->strm_pos += (gfc_offset) nbytes;
+ dtp->u.p.current_unit->bytes_left -= (gfc_offset) nbytes;
return SUCCESS;
}
dtp->u.p.current_unit->bytes_left_subrecord -=
(gfc_offset) to_write_subrecord;
- to_write_subrecord = swrite (dtp->u.p.current_unit->s,
- buf + have_written, to_write_subrecord);
- if (unlikely (to_write_subrecord < 0))
+ if (unlikely (swrite (dtp->u.p.current_unit->s, buf + have_written,
+ &to_write_subrecord) != 0))
{
generate_error (&dtp->common, LIBERROR_OS, NULL);
return FAILURE;
formatted_transfer_scalar (st_parameter_dt *dtp, bt type, void *p, int kind,
size_t size)
{
+ char scratch[SCRATCH_SIZE];
int pos, bytes_used;
const fnode *f;
format_token t;
dtp->u.p.sf_read_comma =
dtp->u.p.current_unit->decimal_status == DECIMAL_COMMA ? 0 : 1;
+ dtp->u.p.line_buffer = scratch;
+
for (;;)
{
/* If reversion has occurred and there is another real data item,
if (is_internal_unit (dtp))
move_pos_offset (dtp->u.p.current_unit->s, dtp->u.p.skips);
else
- fbuf_seek (dtp->u.p.current_unit, dtp->u.p.skips, SEEK_CUR);
+ fbuf_seek (dtp->u.p.current_unit, dtp->u.p.skips);
dtp->u.p.current_unit->bytes_left -= (gfc_offset) dtp->u.p.skips;
}
dtp->u.p.skips = dtp->u.p.pending_spaces = 0;
break;
case BT_REAL:
if (f->u.real.w == 0)
- write_real_g0 (dtp, p, kind, f->u.real.d);
+ write_real_g0 (dtp, p, kind, f->u.real.d);
else
write_d (dtp, f, p, kind);
break;
dtp->u.p.skips += f->u.n;
pos = bytes_used + dtp->u.p.skips - 1;
dtp->u.p.pending_spaces = pos - dtp->u.p.max_pos + 1;
+
/* Writes occur just before the switch on f->format, above, so
that trailing blanks are suppressed, unless we are doing a
non-advancing write in which case we want to output the blanks
/* Adjust everything for end-of-record condition */
if (dtp->u.p.sf_seen_eor && !is_internal_unit (dtp))
{
- dtp->u.p.current_unit->bytes_left -= dtp->u.p.sf_seen_eor;
- dtp->u.p.skips -= dtp->u.p.sf_seen_eor;
+ if (dtp->u.p.sf_seen_eor == 2)
+ {
+ /* The EOR was a CRLF (two bytes wide). */
+ dtp->u.p.current_unit->bytes_left -= 2;
+ dtp->u.p.skips -= 2;
+ }
+ else
+ {
+ /* The EOR marker was only one byte wide. */
+ dtp->u.p.current_unit->bytes_left--;
+ dtp->u.p.skips--;
+ }
bytes_used = pos;
dtp->u.p.sf_seen_eor = 0;
}
if (dtp->u.p.skips < 0)
{
- if (is_internal_unit (dtp))
- move_pos_offset (dtp->u.p.current_unit->s, dtp->u.p.skips);
- else
- fbuf_seek (dtp->u.p.current_unit, dtp->u.p.skips, SEEK_CUR);
+ move_pos_offset (dtp->u.p.current_unit->s, dtp->u.p.skips);
dtp->u.p.current_unit->bytes_left
-= (gfc_offset) dtp->u.p.skips;
dtp->u.p.skips = dtp->u.p.pending_spaces = 0;
internal_error (&dtp->common, "Bad format node");
}
+ /* Free a buffer that we had to allocate during a sequential
+ formatted read of a block that was larger than the static
+ buffer. */
+
+ if (dtp->u.p.line_buffer != scratch)
+ {
+ free_mem (dtp->u.p.line_buffer);
+ dtp->u.p.line_buffer = scratch;
+ }
+
/* Adjust the item count and data pointer. */
if ((consume_data_flag > 0) && (n > 0))
static void
us_read (st_parameter_dt *dtp, int continued)
{
- ssize_t n, nr;
+ size_t n, nr;
GFC_INTEGER_4 i4;
GFC_INTEGER_8 i8;
gfc_offset i;
+ if (dtp->u.p.current_unit->endfile == AT_ENDFILE)
+ return;
+
if (compile_options.record_marker == 0)
n = sizeof (GFC_INTEGER_4);
else
n = compile_options.record_marker;
- nr = sread (dtp->u.p.current_unit->s, &i, n);
- if (unlikely (nr < 0))
+ nr = n;
+
+ if (unlikely (sread (dtp->u.p.current_unit->s, &i, &n) != 0))
{
generate_error (&dtp->common, LIBERROR_BAD_US, NULL);
return;
}
- else if (nr == 0)
+
+ if (n == 0)
{
- hit_eof (dtp);
+ dtp->u.p.current_unit->endfile = AT_ENDFILE;
return; /* end of file */
}
- else if (unlikely (n != nr))
+
+ if (unlikely (n != nr))
{
generate_error (&dtp->common, LIBERROR_BAD_US, NULL);
return;
static void
us_write (st_parameter_dt *dtp, int continued)
{
- ssize_t nbytes;
+ size_t nbytes;
gfc_offset dummy;
dummy = 0;
else
nbytes = compile_options.record_marker ;
- if (swrite (dtp->u.p.current_unit->s, &dummy, nbytes) != nbytes)
+ if (swrite (dtp->u.p.current_unit->s, &dummy, &nbytes) != 0)
generate_error (&dtp->common, LIBERROR_OS, NULL);
/* For sequential unformatted, if RECL= was not specified in the OPEN
return;
}
- /* Check the record or position number. */
+ /* Check the record number. */
if (dtp->u.p.current_unit->flags.access == ACCESS_DIRECT
&& (cf & IOPARM_DT_HAS_REC) == 0)
if (dtp->u.p.current_unit->pad_status == PAD_UNSPECIFIED)
dtp->u.p.current_unit->pad_status = dtp->u.p.current_unit->flags.pad;
-
- /* Check to see if we might be reading what we wrote before */
-
- if (dtp->u.p.mode != dtp->u.p.current_unit->mode
- && !is_internal_unit (dtp))
- {
- int pos = fbuf_reset (dtp->u.p.current_unit);
- if (pos != 0)
- sseek (dtp->u.p.current_unit->s, pos, SEEK_CUR);
- sflush(dtp->u.p.current_unit->s);
- }
-
+
/* Check the POS= specifier: that it is in range and that it is used with a
unit that has been connected for STREAM access. F2003 9.5.1.10. */
if (((cf & IOPARM_DT_HAS_POS) != 0))
{
if (is_stream_io (dtp))
- {
-
- if (dtp->pos <= 0)
- {
- generate_error (&dtp->common, LIBERROR_BAD_OPTION,
- "POS=specifier must be positive");
- return;
- }
-
- if (dtp->pos >= dtp->u.p.current_unit->maxrec)
- {
- generate_error (&dtp->common, LIBERROR_BAD_OPTION,
- "POS=specifier too large");
- return;
- }
-
- dtp->rec = dtp->pos;
-
- if (dtp->u.p.mode == READING)
- {
- /* Reset the endfile flag; if we hit EOF during reading
- we'll set the flag and generate an error at that point
- rather than worrying about it here. */
- dtp->u.p.current_unit->endfile = NO_ENDFILE;
- }
-
- if (dtp->pos != dtp->u.p.current_unit->strm_pos)
- {
- fbuf_flush (dtp->u.p.current_unit, dtp->u.p.mode);
- sflush (dtp->u.p.current_unit->s);
- if (sseek (dtp->u.p.current_unit->s, dtp->pos - 1, SEEK_SET) < 0)
- {
- generate_error (&dtp->common, LIBERROR_OS, NULL);
- return;
- }
- dtp->u.p.current_unit->strm_pos = dtp->pos;
- }
- }
+ {
+
+ if (dtp->pos <= 0)
+ {
+ generate_error (&dtp->common, LIBERROR_BAD_OPTION,
+ "POS=specifier must be positive");
+ return;
+ }
+
+ if (dtp->pos >= dtp->u.p.current_unit->maxrec)
+ {
+ generate_error (&dtp->common, LIBERROR_BAD_OPTION,
+ "POS=specifier too large");
+ return;
+ }
+
+ dtp->rec = dtp->pos;
+
+ if (dtp->u.p.mode == READING)
+ {
+ /* Required for compatibility between 4.3 and 4.4 runtime. Check
+ to see if we might be reading what we wrote before */
+ if (dtp->u.p.current_unit->mode == WRITING)
+ {
+ fbuf_flush (dtp->u.p.current_unit, 1);
+ flush(dtp->u.p.current_unit->s);
+ }
+
+ if (dtp->pos < file_length (dtp->u.p.current_unit->s))
+ dtp->u.p.current_unit->endfile = NO_ENDFILE;
+ }
+
+ if (dtp->pos != dtp->u.p.current_unit->strm_pos)
+ {
+ fbuf_flush (dtp->u.p.current_unit, 1);
+ flush (dtp->u.p.current_unit->s);
+ if (sseek (dtp->u.p.current_unit->s, dtp->pos - 1) == FAILURE)
+ {
+ generate_error (&dtp->common, LIBERROR_OS, NULL);
+ return;
+ }
+ dtp->u.p.current_unit->strm_pos = dtp->pos;
+ }
+ }
else
- {
- generate_error (&dtp->common, LIBERROR_BAD_OPTION,
- "POS=specifier not allowed, "
- "Try OPEN with ACCESS='stream'");
- return;
- }
+ {
+ generate_error (&dtp->common, LIBERROR_BAD_OPTION,
+ "POS=specifier not allowed, "
+ "Try OPEN with ACCESS='stream'");
+ return;
+ }
}
-
/* Sanity checks on the record number. */
if ((cf & IOPARM_DT_HAS_REC) != 0)
return;
}
- /* Make sure format buffer is reset. */
- if (dtp->u.p.current_unit->flags.form == FORM_FORMATTED)
- fbuf_reset (dtp->u.p.current_unit);
+ /* Check to see if we might be reading what we wrote before */
+ if (dtp->u.p.mode == READING
+ && dtp->u.p.current_unit->mode == WRITING
+ && !is_internal_unit (dtp))
+ {
+ fbuf_flush (dtp->u.p.current_unit, 1);
+ flush(dtp->u.p.current_unit->s);
+ }
/* Check whether the record exists to be read. Only
a partial record needs to exist. */
/* Position the file. */
if (sseek (dtp->u.p.current_unit->s, (gfc_offset) (dtp->rec - 1)
- * dtp->u.p.current_unit->recl, SEEK_SET) < 0)
- {
- generate_error (&dtp->common, LIBERROR_OS, NULL);
- return;
- }
+ * dtp->u.p.current_unit->recl) == FAILURE)
+ {
+ generate_error (&dtp->common, LIBERROR_OS, NULL);
+ return;
+ }
/* TODO: This is required to maintain compatibility between
- 4.3 and 4.4 runtime. Remove when ABI changes from 4.3 */
+ 4.3 and 4.4 runtime. Remove when ABI changes from 4.3 */
if (is_stream_io (dtp))
- dtp->u.p.current_unit->strm_pos = dtp->rec;
-
+ dtp->u.p.current_unit->strm_pos = dtp->rec;
+
/* TODO: Un-comment this code when ABI changes from 4.3.
if (dtp->u.p.current_unit->flags.access == ACCESS_STREAM)
- {
- generate_error (&dtp->common, LIBERROR_OPTION_CONFLICT,
- "Record number not allowed for stream access "
- "data transfer");
- return;
- } */
+ {
+ generate_error (&dtp->common, LIBERROR_OPTION_CONFLICT,
+ "Record number not allowed for stream access "
+ "data transfer");
+ return;
+ } */
+
}
+ /* Overwriting an existing sequential file ?
+ it is always safe to truncate the file on the first write */
+ if (dtp->u.p.mode == WRITING
+ && dtp->u.p.current_unit->flags.access == ACCESS_SEQUENTIAL
+ && dtp->u.p.current_unit->last_record == 0
+ && !is_preconnected(dtp->u.p.current_unit->s))
+ struncate(dtp->u.p.current_unit->s);
+
/* Bugware for badly written mixed C-Fortran I/O. */
flush_if_preconnected(dtp->u.p.current_unit->s);
static void
skip_record (st_parameter_dt *dtp, size_t bytes)
{
+ gfc_offset new;
size_t rlength;
- ssize_t readb;
static const size_t MAX_READ = 4096;
char p[MAX_READ];
if (is_seekable (dtp->u.p.current_unit->s))
{
+ new = file_position (dtp->u.p.current_unit->s)
+ + dtp->u.p.current_unit->bytes_left_subrecord;
+
/* Direct access files do not generate END conditions,
only I/O errors. */
- if (sseek (dtp->u.p.current_unit->s,
- dtp->u.p.current_unit->bytes_left_subrecord, SEEK_CUR) < 0)
+ if (sseek (dtp->u.p.current_unit->s, new) == FAILURE)
generate_error (&dtp->common, LIBERROR_OS, NULL);
}
else
while (dtp->u.p.current_unit->bytes_left_subrecord > 0)
{
rlength =
- (MAX_READ < (size_t) dtp->u.p.current_unit->bytes_left_subrecord) ?
+ (MAX_READ > (size_t) dtp->u.p.current_unit->bytes_left_subrecord) ?
MAX_READ : (size_t) dtp->u.p.current_unit->bytes_left_subrecord;
- readb = sread (dtp->u.p.current_unit->s, p, rlength);
- if (readb < 0)
+ if (sread (dtp->u.p.current_unit->s, p, &rlength) != 0)
{
generate_error (&dtp->common, LIBERROR_OS, NULL);
return;
}
- dtp->u.p.current_unit->bytes_left_subrecord -= readb;
+ dtp->u.p.current_unit->bytes_left_subrecord -= rlength;
}
}
{
gfc_offset record;
int bytes_left;
+ size_t length;
char p;
- int cc;
switch (current_mode (dtp))
{
case FORMATTED_STREAM:
case FORMATTED_SEQUENTIAL:
- /* read_sf has already terminated input because of an '\n', or
- we have hit EOF. */
- if (dtp->u.p.sf_seen_eor || dtp->u.p.at_eof)
+ length = 1;
+ /* sf_read has already terminated input because of an '\n' */
+ if (dtp->u.p.sf_seen_eor)
{
dtp->u.p.sf_seen_eor = 0;
- dtp->u.p.at_eof = 0;
break;
}
/* Now seek to this record. */
record = record * dtp->u.p.current_unit->recl;
- if (sseek (dtp->u.p.current_unit->s, record, SEEK_SET) < 0)
+ if (sseek (dtp->u.p.current_unit->s, record) == FAILURE)
{
generate_error (&dtp->common, LIBERROR_INTERNAL_UNIT, NULL);
break;
bytes_left = (int) dtp->u.p.current_unit->bytes_left;
bytes_left = min_off (bytes_left,
file_length (dtp->u.p.current_unit->s)
- - stell (dtp->u.p.current_unit->s));
+ - file_position (dtp->u.p.current_unit->s));
if (sseek (dtp->u.p.current_unit->s,
- bytes_left, SEEK_CUR) < 0)
+ file_position (dtp->u.p.current_unit->s)
+ + bytes_left) == FAILURE)
{
generate_error (&dtp->common, LIBERROR_INTERNAL_UNIT, NULL);
break;
}
break;
}
- else
+ else do
{
- do
+ if (sread (dtp->u.p.current_unit->s, &p, &length) != 0)
{
- errno = 0;
- cc = fbuf_getc (dtp->u.p.current_unit);
- if (cc == EOF)
- {
- if (errno != 0)
- generate_error (&dtp->common, LIBERROR_OS, NULL);
- else
- hit_eof (dtp);
- break;
- }
-
- if (is_stream_io (dtp))
- dtp->u.p.current_unit->strm_pos++;
-
- p = (char) cc;
+ generate_error (&dtp->common, LIBERROR_OS, NULL);
+ break;
}
- while (p != '\n');
+
+ if (length == 0)
+ {
+ dtp->u.p.current_unit->endfile = AT_ENDFILE;
+ break;
+ }
+
+ if (is_stream_io (dtp))
+ dtp->u.p.current_unit->strm_pos++;
}
+ while (p != '\n');
+
break;
}
+
+ if (dtp->u.p.current_unit->flags.access == ACCESS_SEQUENTIAL
+ && !dtp->u.p.namelist_mode
+ && dtp->u.p.current_unit->endfile == NO_ENDFILE
+ && (file_length (dtp->u.p.current_unit->s) ==
+ file_position (dtp->u.p.current_unit->s)))
+ dtp->u.p.current_unit->endfile = AT_ENDFILE;
+
}
/* Small utility function to write a record marker, taking care of
byte swapping and of choosing the correct size. */
-static int
+inline static int
write_us_marker (st_parameter_dt *dtp, const gfc_offset buf)
{
size_t len;
{
case sizeof (GFC_INTEGER_4):
buf4 = buf;
- return swrite (dtp->u.p.current_unit->s, &buf4, len);
+ return swrite (dtp->u.p.current_unit->s, &buf4, &len);
break;
case sizeof (GFC_INTEGER_8):
buf8 = buf;
- return swrite (dtp->u.p.current_unit->s, &buf8, len);
+ return swrite (dtp->u.p.current_unit->s, &buf8, &len);
break;
default:
case sizeof (GFC_INTEGER_4):
buf4 = buf;
reverse_memcpy (p, &buf4, sizeof (GFC_INTEGER_4));
- return swrite (dtp->u.p.current_unit->s, p, len);
+ return swrite (dtp->u.p.current_unit->s, p, &len);
break;
case sizeof (GFC_INTEGER_8):
buf8 = buf;
reverse_memcpy (p, &buf8, sizeof (GFC_INTEGER_8));
- return swrite (dtp->u.p.current_unit->s, p, len);
+ return swrite (dtp->u.p.current_unit->s, p, &len);
break;
default:
/* Bytes written. */
m = dtp->u.p.current_unit->recl_subrecord
- dtp->u.p.current_unit->bytes_left_subrecord;
- c = stell (dtp->u.p.current_unit->s);
+ c = file_position (dtp->u.p.current_unit->s);
/* Write the length tail. If we finish a record containing
subrecords, we write out the negative length. */
else
m_write = m;
- if (unlikely (write_us_marker (dtp, m_write) < 0))
+ if (unlikely (write_us_marker (dtp, m_write) != 0))
goto io_error;
if (compile_options.record_marker == 0)
/* Seek to the head and overwrite the bogus length with the real
length. */
- if (unlikely (sseek (dtp->u.p.current_unit->s, c - m - record_marker,
- SEEK_SET) < 0))
+ if (unlikely (sseek (dtp->u.p.current_unit->s, c - m - record_marker)
+ == FAILURE))
goto io_error;
if (next_subrecord)
else
m_write = m;
- if (unlikely (write_us_marker (dtp, m_write) < 0))
+ if (unlikely (write_us_marker (dtp, m_write) != 0))
goto io_error;
/* Seek past the end of the current record. */
- if (unlikely (sseek (dtp->u.p.current_unit->s, c + record_marker,
- SEEK_SET) < 0))
+ if (unlikely (sseek (dtp->u.p.current_unit->s, c + record_marker)
+ == FAILURE))
goto io_error;
return;
}
-
-/* Utility function like memset() but operating on streams. Return
- value is same as for POSIX write(). */
-
-static ssize_t
-sset (stream * s, int c, ssize_t nbyte)
-{
- static const int WRITE_CHUNK = 256;
- char p[WRITE_CHUNK];
- ssize_t bytes_left, trans;
-
- if (nbyte < WRITE_CHUNK)
- memset (p, c, nbyte);
- else
- memset (p, c, WRITE_CHUNK);
-
- bytes_left = nbyte;
- while (bytes_left > 0)
- {
- trans = (bytes_left < WRITE_CHUNK) ? bytes_left : WRITE_CHUNK;
- trans = swrite (s, p, trans);
- if (trans < 0)
- return trans;
- bytes_left -= trans;
- }
-
- return nbyte - bytes_left;
-}
-
/* Position to the next record in write mode. */
static void
gfc_offset m, record, max_pos;
int length;
+ /* Flush and reset the format buffer. */
+ fbuf_flush (dtp->u.p.current_unit, 1);
+
/* Zero counters for X- and T-editing. */
max_pos = dtp->u.p.max_pos;
dtp->u.p.max_pos = dtp->u.p.skips = dtp->u.p.pending_spaces = 0;
if (dtp->u.p.current_unit->bytes_left == 0)
break;
- fbuf_seek (dtp->u.p.current_unit, 0, SEEK_END);
- fbuf_flush (dtp->u.p.current_unit, WRITING);
if (sset (dtp->u.p.current_unit->s, ' ',
- dtp->u.p.current_unit->bytes_left)
- != dtp->u.p.current_unit->bytes_left)
+ dtp->u.p.current_unit->bytes_left) == FAILURE)
goto io_error;
break;
if (dtp->u.p.current_unit->bytes_left > 0)
{
length = (int) dtp->u.p.current_unit->bytes_left;
- if (sset (dtp->u.p.current_unit->s, 0, length) != length)
+ if (sset (dtp->u.p.current_unit->s, 0, length) == FAILURE)
goto io_error;
}
break;
{
length = (int) (max_pos - m);
if (sseek (dtp->u.p.current_unit->s,
- length, SEEK_CUR) < 0)
+ file_position (dtp->u.p.current_unit->s)
+ + length) == FAILURE)
{
generate_error (&dtp->common, LIBERROR_INTERNAL_UNIT, NULL);
return;
length = (int) (dtp->u.p.current_unit->recl - max_pos);
}
- if (sset (dtp->u.p.current_unit->s, ' ', length) != length)
+ if (sset (dtp->u.p.current_unit->s, ' ', length) == FAILURE)
{
generate_error (&dtp->common, LIBERROR_END, NULL);
return;
/* Now seek to this record */
record = record * dtp->u.p.current_unit->recl;
- if (sseek (dtp->u.p.current_unit->s, record, SEEK_SET) < 0)
+ if (sseek (dtp->u.p.current_unit->s, record) == FAILURE)
{
generate_error (&dtp->common, LIBERROR_INTERNAL_UNIT, NULL);
return;
{
length = (int) (max_pos - m);
if (sseek (dtp->u.p.current_unit->s,
- length, SEEK_CUR) < 0)
+ file_position (dtp->u.p.current_unit->s)
+ + length) == FAILURE)
{
generate_error (&dtp->common, LIBERROR_INTERNAL_UNIT, NULL);
return;
length = (int) dtp->u.p.current_unit->bytes_left;
}
- if (sset (dtp->u.p.current_unit->s, ' ', length) != length)
+ if (sset (dtp->u.p.current_unit->s, ' ', length) == FAILURE)
{
generate_error (&dtp->common, LIBERROR_END, NULL);
return;
}
else
{
+ size_t len;
+ const char crlf[] = "\r\n";
+
#ifdef HAVE_CRLF
- const int len = 2;
+ len = 2;
#else
- const int len = 1;
-#endif
- fbuf_seek (dtp->u.p.current_unit, 0, SEEK_END);
- char * p = fbuf_alloc (dtp->u.p.current_unit, len);
- if (!p)
- goto io_error;
-#ifdef HAVE_CRLF
- *(p++) = '\r';
+ len = 1;
#endif
- *p = '\n';
+ if (swrite (dtp->u.p.current_unit->s, &crlf[2-len], &len) != 0)
+ goto io_error;
+
if (is_stream_io (dtp))
{
dtp->u.p.current_unit->strm_pos += len;
if (dtp->u.p.current_unit->strm_pos
< file_length (dtp->u.p.current_unit->s))
- unit_truncate (dtp->u.p.current_unit,
- dtp->u.p.current_unit->strm_pos - 1,
- &dtp->common);
+ struncate (dtp->u.p.current_unit->s);
}
}
dtp->u.p.current_unit->current_record = 0;
if (dtp->u.p.current_unit->flags.access == ACCESS_DIRECT)
{
- fp = stell (dtp->u.p.current_unit->s);
+ fp = file_position (dtp->u.p.current_unit->s);
/* Calculate next record, rounding up partial records. */
dtp->u.p.current_unit->last_record =
(fp + dtp->u.p.current_unit->recl - 1) /
if (!done)
pre_position (dtp);
-
- fbuf_flush (dtp->u.p.current_unit, dtp->u.p.mode);
}
if ((cf & IOPARM_DT_LIST_FORMAT) != 0 && dtp->u.p.mode == READING)
{
finish_list_read (dtp);
+ sfree (dtp->u.p.current_unit->s);
return;
}
next_record (dtp, 1);
if (dtp->u.p.current_unit->flags.form == FORM_UNFORMATTED
- && stell (dtp->u.p.current_unit->s) >= dtp->rec)
+ && file_position (dtp->u.p.current_unit->s) >= dtp->rec)
{
- sflush (dtp->u.p.current_unit->s);
+ flush (dtp->u.p.current_unit->s);
+ sfree (dtp->u.p.current_unit->s);
}
return;
}
if (!is_internal_unit (dtp) && dtp->u.p.seen_dollar)
{
- fbuf_flush (dtp->u.p.current_unit, dtp->u.p.mode);
dtp->u.p.seen_dollar = 0;
+ fbuf_flush (dtp->u.p.current_unit, 1);
+ sfree (dtp->u.p.current_unit->s);
return;
}
- dtp->u.p.current_unit->bytes_left);
dtp->u.p.current_unit->saved_pos =
dtp->u.p.max_pos > 0 ? dtp->u.p.max_pos - bytes_written : 0;
- fbuf_flush (dtp->u.p.current_unit, dtp->u.p.mode);
- sflush (dtp->u.p.current_unit->s);
+ fbuf_flush (dtp->u.p.current_unit, 0);
+ flush (dtp->u.p.current_unit->s);
return;
}
- else if (dtp->u.p.current_unit->flags.form == FORM_FORMATTED
- && dtp->u.p.mode == WRITING && !is_internal_unit (dtp))
- fbuf_seek (dtp->u.p.current_unit, 0, SEEK_END);
dtp->u.p.current_unit->saved_pos = 0;
next_record (dtp, 1);
+ sfree (dtp->u.p.current_unit->s);
}
/* Transfer function for IOLENGTH. It doesn't actually do any
st_iolength_done (st_parameter_dt *dtp __attribute__((unused)))
{
free_ionml (dtp);
+ if (dtp->u.p.scratch != NULL)
+ free_mem (dtp->u.p.scratch);
library_end ();
}
library_start (&dtp->common);
data_transfer_init (dtp, 1);
+
+ /* Handle complications dealing with the endfile record. */
+
+ if (dtp->u.p.current_unit->flags.access == ACCESS_SEQUENTIAL)
+ switch (dtp->u.p.current_unit->endfile)
+ {
+ case NO_ENDFILE:
+ break;
+
+ case AT_ENDFILE:
+ if (!is_internal_unit (dtp))
+ {
+ generate_error (&dtp->common, LIBERROR_END, NULL);
+ dtp->u.p.current_unit->endfile = AFTER_ENDFILE;
+ dtp->u.p.current_unit->current_record = 0;
+ }
+ break;
+
+ case AFTER_ENDFILE:
+ generate_error (&dtp->common, LIBERROR_ENDFILE, NULL);
+ dtp->u.p.current_unit->current_record = 0;
+ break;
+ }
}
extern void st_read_done (st_parameter_dt *);
finalize_transfer (dtp);
free_format_data (dtp);
free_ionml (dtp);
+ if (dtp->u.p.scratch != NULL)
+ free_mem (dtp->u.p.scratch);
if (dtp->u.p.current_unit != NULL)
unlock_unit (dtp->u.p.current_unit);
case NO_ENDFILE:
/* Get rid of whatever is after this record. */
if (!is_internal_unit (dtp))
- unit_truncate (dtp->u.p.current_unit,
- stell (dtp->u.p.current_unit->s),
- &dtp->common);
+ {
+ flush (dtp->u.p.current_unit->s);
+ if (struncate (dtp->u.p.current_unit->s) == FAILURE)
+ generate_error (&dtp->common, LIBERROR_OS, NULL);
+ }
dtp->u.p.current_unit->endfile = AT_ENDFILE;
break;
}
free_format_data (dtp);
free_ionml (dtp);
+ if (dtp->u.p.scratch != NULL)
+ free_mem (dtp->u.p.scratch);
if (dtp->u.p.current_unit != NULL)
unlock_unit (dtp->u.p.current_unit);
for (i=0; i<n; i++)
*(d++) = *(s--);
}
-
-
-/* Once upon a time, a poor innocent Fortran program was reading a
- file, when suddenly it hit the end-of-file (EOF). Unfortunately
- the OS doesn't tell whether we're at the EOF or whether we already
- went past it. Luckily our hero, libgfortran, keeps track of this.
- Call this function when you detect an EOF condition. See Section
- 9.10.2 in F2003. */
-
-void
-hit_eof (st_parameter_dt * dtp)
-{
- dtp->u.p.current_unit->flags.position = POSITION_APPEND;
-
- if (dtp->u.p.current_unit->flags.access == ACCESS_SEQUENTIAL)
- switch (dtp->u.p.current_unit->endfile)
- {
- case NO_ENDFILE:
- case AT_ENDFILE:
- generate_error (&dtp->common, LIBERROR_END, NULL);
- if (!is_internal_unit (dtp))
- {
- dtp->u.p.current_unit->endfile = AFTER_ENDFILE;
- dtp->u.p.current_unit->current_record = 0;
- }
- else
- dtp->u.p.current_unit->endfile = AT_ENDFILE;
- break;
-
- case AFTER_ENDFILE:
- generate_error (&dtp->common, LIBERROR_ENDFILE, NULL);
- dtp->u.p.current_unit->current_record = 0;
- break;
- }
- else
- {
- /* Non-sequential files don't have an ENDFILE record, so we
- can't be at AFTER_ENDFILE. */
- dtp->u.p.current_unit->endfile = AT_ENDFILE;
- generate_error (&dtp->common, LIBERROR_END, NULL);
- dtp->u.p.current_unit->current_record = 0;
- }
-}
projects / platform / upstream / gcc.git / commitdiff