657 lines
15 KiB
C++
657 lines
15 KiB
C++
/* Copyright (C) 2002-2003 Free Software Foundation, Inc.
|
|
Contributed by Andy Vaught
|
|
|
|
This file is part of the GNU Fortran 95 runtime library (libgfortran).
|
|
|
|
Libgfortran is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
Libgfortran is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Libgfortran; see the file COPYING. If not, write to
|
|
the Free Software Foundation, 59 Temple Place - Suite 330,
|
|
Boston, MA 02111-1307, USA. */
|
|
|
|
#ifndef GFOR_IO_H
|
|
#define GFOR_IO_H
|
|
|
|
/* IO library include. */
|
|
|
|
#include <setjmp.h>
|
|
#include "libgfortran.h"
|
|
#define DEFAULT_TEMPDIR "/var/tmp"
|
|
|
|
/* Basic types used in data transfers. */
|
|
|
|
typedef enum
|
|
{ BT_NULL, BT_INTEGER, BT_LOGICAL, BT_CHARACTER, BT_REAL,
|
|
BT_COMPLEX
|
|
}
|
|
bt;
|
|
|
|
|
|
typedef enum
|
|
{ SUCCESS = 1, FAILURE }
|
|
try;
|
|
|
|
typedef struct stream
|
|
{
|
|
char *(*alloc_w_at) (struct stream *, int *, gfc_offset);
|
|
char *(*alloc_r_at) (struct stream *, int *, gfc_offset);
|
|
try (*sfree) (struct stream *);
|
|
try (*close) (struct stream *);
|
|
try (*seek) (struct stream *, gfc_offset);
|
|
try (*truncate) (struct stream *);
|
|
}
|
|
stream;
|
|
|
|
|
|
/* Macros for doing file I/O given a stream. */
|
|
|
|
#define sfree(s) ((s)->sfree)(s)
|
|
#define sclose(s) ((s)->close)(s)
|
|
|
|
#define salloc_r(s, len) ((s)->alloc_r_at)(s, len, -1)
|
|
#define salloc_w(s, len) ((s)->alloc_w_at)(s, len, -1)
|
|
|
|
#define salloc_r_at(s, len, where) ((s)->alloc_r_at)(s, len, where)
|
|
#define salloc_w_at(s, len, where) ((s)->alloc_w_at)(s, len, where)
|
|
|
|
#define sseek(s, pos) ((s)->seek)(s, pos)
|
|
#define struncate(s) ((s)->truncate)(s)
|
|
|
|
/* Namelist represent object */
|
|
/*
|
|
Namelist Records
|
|
&groupname object=value [,object=value].../
|
|
or
|
|
&groupname object=value [,object=value]...&groupname
|
|
|
|
Even more complex, during the execution of a program containing a
|
|
namelist READ statement, you can specify a question mark character(?)
|
|
or a question mark character preceded by an equal sign(=?) to get
|
|
the information of the namelist group. By '?', the name of variables
|
|
in the namelist will be displayed, by '=?', the name and value of
|
|
variables will be displayed.
|
|
|
|
All these requirements need a new data structure to record all info
|
|
about the namelist.
|
|
*/
|
|
|
|
typedef struct namelist_type
|
|
{
|
|
char * var_name;
|
|
void * mem_pos;
|
|
int value_acquired;
|
|
int len;
|
|
bt type;
|
|
struct namelist_type * next;
|
|
}
|
|
namelist_info;
|
|
|
|
/* Options for the OPEN statement. */
|
|
|
|
typedef enum
|
|
{ ACCESS_SEQUENTIAL, ACCESS_DIRECT,
|
|
ACCESS_UNSPECIFIED
|
|
}
|
|
unit_access;
|
|
|
|
typedef enum
|
|
{ ACTION_READ, ACTION_WRITE, ACTION_READWRITE,
|
|
ACTION_UNSPECIFIED
|
|
}
|
|
unit_action;
|
|
|
|
typedef enum
|
|
{ BLANK_NULL, BLANK_ZERO, BLANK_UNSPECIFIED }
|
|
unit_blank;
|
|
|
|
typedef enum
|
|
{ DELIM_NONE, DELIM_APOSTROPHE, DELIM_QUOTE,
|
|
DELIM_UNSPECIFIED
|
|
}
|
|
unit_delim;
|
|
|
|
typedef enum
|
|
{ FORM_FORMATTED, FORM_UNFORMATTED, FORM_UNSPECIFIED }
|
|
unit_form;
|
|
|
|
typedef enum
|
|
{ POSITION_ASIS, POSITION_REWIND, POSITION_APPEND,
|
|
POSITION_UNSPECIFIED
|
|
}
|
|
unit_position;
|
|
|
|
typedef enum
|
|
{ STATUS_UNKNOWN, STATUS_OLD, STATUS_NEW, STATUS_SCRATCH,
|
|
STATUS_REPLACE, STATUS_UNSPECIFIED
|
|
}
|
|
unit_status;
|
|
|
|
typedef enum
|
|
{ PAD_YES, PAD_NO, PAD_UNSPECIFIED }
|
|
unit_pad;
|
|
|
|
typedef enum
|
|
{ ADVANCE_YES, ADVANCE_NO, ADVANCE_UNSPECIFIED }
|
|
unit_advance;
|
|
|
|
|
|
|
|
/* Statement parameters. These are all the things that can appear in
|
|
an I/O statement. Some are inputs and some are outputs, but none
|
|
are both. All of these values are initially zeroed and are zeroed
|
|
at the end of a library statement. The relevant values need to be
|
|
set before entry to an I/O statement. This structure needs to be
|
|
duplicated by the back end. */
|
|
|
|
typedef struct
|
|
{
|
|
int unit;
|
|
int err, end, eor, list_format; /* These are flags, not values. */
|
|
|
|
/* Return values from library statements. These are returned only if
|
|
the labels are specified in the statement itself and the condition
|
|
occurs. In most cases, none of the labels are specified and the
|
|
return value does not have to be checked. Must be consistent with
|
|
the front end. */
|
|
|
|
enum
|
|
{
|
|
LIBRARY_OK = 0,
|
|
LIBRARY_ERROR,
|
|
LIBRARY_END,
|
|
LIBRARY_EOR
|
|
}
|
|
library_return;
|
|
|
|
int *iostat, *exist, *opened, *number, *named, rec, *nextrec, *size;
|
|
|
|
int recl_in;
|
|
int *recl_out;
|
|
|
|
char *file;
|
|
int file_len;
|
|
char *status;
|
|
int status_len;
|
|
char *access;
|
|
int access_len;
|
|
char *form;
|
|
int form_len;
|
|
char *blank;
|
|
int blank_len;
|
|
char *position;
|
|
int position_len;
|
|
char *action;
|
|
int action_len;
|
|
char *delim;
|
|
int delim_len;
|
|
char *pad;
|
|
int pad_len;
|
|
char *format;
|
|
int format_len;
|
|
char *advance;
|
|
int advance_len;
|
|
char *name;
|
|
int name_len;
|
|
char *internal_unit;
|
|
int internal_unit_len;
|
|
char *sequential;
|
|
int sequential_len;
|
|
char *direct;
|
|
int direct_len;
|
|
char *formatted;
|
|
int formatted_len;
|
|
char *unformatted;
|
|
int unformatted_len;
|
|
char *read;
|
|
int read_len;
|
|
char *write;
|
|
int write_len;
|
|
char *readwrite;
|
|
int readwrite_len;
|
|
|
|
/* namelist related data */
|
|
char * namelist_name;
|
|
int namelist_name_len;
|
|
int namelist_read_mode;
|
|
}
|
|
st_parameter;
|
|
|
|
|
|
|
|
#define ioparm prefix(ioparm)
|
|
extern st_parameter ioparm;
|
|
|
|
#define ionml prefix(ionml)
|
|
extern namelist_info * ionml;
|
|
|
|
typedef struct
|
|
{
|
|
unit_access access;
|
|
unit_action action;
|
|
unit_blank blank;
|
|
unit_delim delim;
|
|
unit_form form;
|
|
int is_notpadded;
|
|
unit_position position;
|
|
unit_status status;
|
|
unit_pad pad;
|
|
}
|
|
unit_flags;
|
|
|
|
|
|
/* The default value of record length is defined here. This value can
|
|
be overriden by the OPEN statement or by an environment variable. */
|
|
|
|
#define DEFAULT_RECL 10000
|
|
|
|
|
|
typedef struct gfc_unit
|
|
{
|
|
int unit_number;
|
|
|
|
stream *s;
|
|
|
|
struct gfc_unit *left, *right; /* Treap links. */
|
|
int priority;
|
|
|
|
int read_bad, current_record;
|
|
enum
|
|
{ NO_ENDFILE, AT_ENDFILE, AFTER_ENDFILE }
|
|
endfile;
|
|
|
|
unit_flags flags;
|
|
gfc_offset recl, last_record, maxrec, bytes_left;
|
|
|
|
/* recl -- Record length of the file.
|
|
last_record -- Last record number read or written
|
|
maxrec -- Maximum record number in a direct access file
|
|
bytes_left -- Bytes left in current record. */
|
|
|
|
int file_len;
|
|
char file[1]; /* Filename is allocated at the end of the structure. */
|
|
}
|
|
gfc_unit;
|
|
|
|
/* Global variables. Putting these in a structure makes it easier to
|
|
maintain, particularly with the constraint of a prefix. */
|
|
|
|
typedef struct
|
|
{
|
|
int in_library; /* Nonzero if a library call is being processed. */
|
|
int size; /* Bytes processed by the current data-transfer statement. */
|
|
gfc_offset max_offset; /* Maximum file offset. */
|
|
int item_count; /* Item number in a formatted data transfer. */
|
|
int reversion_flag; /* Format reversion has occurred. */
|
|
int first_item;
|
|
|
|
gfc_unit *unit_root;
|
|
int seen_dollar;
|
|
|
|
enum {READING, WRITING} mode;
|
|
|
|
unit_blank blank_status;
|
|
enum {SIGN_S, SIGN_SS, SIGN_SP} sign_status;
|
|
int scale_factor;
|
|
jmp_buf eof_jump;
|
|
}
|
|
global_t;
|
|
|
|
|
|
#define g prefix(g)
|
|
extern global_t g;
|
|
|
|
|
|
#define current_unit prefix(current_unit)
|
|
extern gfc_unit *current_unit;
|
|
|
|
/* Format tokens. Only about half of these can be stored in the
|
|
format nodes. */
|
|
|
|
typedef enum
|
|
{
|
|
FMT_NONE = 0, FMT_UNKNOWN, FMT_SIGNED_INT, FMT_ZERO, FMT_POSINT, FMT_PERIOD,
|
|
FMT_COMMA, FMT_COLON, FMT_SLASH, FMT_DOLLAR, FMT_T, FMT_TR, FMT_TL,
|
|
FMT_LPAREN, FMT_RPAREN, FMT_X, FMT_S, FMT_SS, FMT_SP, FMT_STRING,
|
|
FMT_BADSTRING, FMT_P, FMT_I, FMT_B, FMT_BN, FMT_BZ, FMT_O, FMT_Z, FMT_F,
|
|
FMT_E, FMT_EN, FMT_ES, FMT_G, FMT_L, FMT_A, FMT_D, FMT_H, FMT_END
|
|
}
|
|
format_token;
|
|
|
|
|
|
/* Format nodes. A format string is converted into a tree of these
|
|
structures, which is traversed as part of a data transfer statement. */
|
|
|
|
typedef struct fnode
|
|
{
|
|
format_token format;
|
|
int repeat;
|
|
struct fnode *next;
|
|
char *source;
|
|
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
int w, d, e;
|
|
}
|
|
real;
|
|
|
|
struct
|
|
{
|
|
int length;
|
|
char *p;
|
|
}
|
|
string;
|
|
|
|
struct
|
|
{
|
|
int w, m;
|
|
}
|
|
integer;
|
|
|
|
int w;
|
|
int k;
|
|
int r;
|
|
int n;
|
|
|
|
struct fnode *child;
|
|
}
|
|
u;
|
|
|
|
/* Members for traversing the tree during data transfer. */
|
|
|
|
int count;
|
|
struct fnode *current;
|
|
|
|
}
|
|
fnode;
|
|
|
|
|
|
/* unix.c */
|
|
|
|
#define sys_exit prefix(sys_exit)
|
|
void sys_exit (int) __attribute__ ((noreturn));
|
|
|
|
#define move_pos_offset prefix(move_pos_offset)
|
|
int move_pos_offset (stream *, int);
|
|
|
|
#define get_oserror prefix(get_oserror)
|
|
const char *get_oserror (void);
|
|
|
|
#define compare_files prefix(compare_files)
|
|
int compare_files (stream *, stream *);
|
|
|
|
#define init_error_stream prefix(init_error_stream)
|
|
stream *init_error_stream (void);
|
|
|
|
#define open_external prefix(open_external)
|
|
stream *open_external (unit_action, unit_status);
|
|
|
|
#define open_internal prefix(open_internal)
|
|
stream *open_internal (char *, int);
|
|
|
|
#define input_stream prefix(input_stream)
|
|
stream *input_stream (void);
|
|
|
|
#define output_stream prefix(output_stream)
|
|
stream *output_stream (void);
|
|
|
|
#define compare_file_filename prefix(compare_file_filename)
|
|
int compare_file_filename (stream *, const char *, int);
|
|
|
|
#define find_file prefix(find_file)
|
|
gfc_unit *find_file (void);
|
|
|
|
#define stream_at_bof prefix(stream_at_bof)
|
|
int stream_at_bof (stream *);
|
|
|
|
#define stream_at_eof prefix(stream_at_eof)
|
|
int stream_at_eof (stream *);
|
|
|
|
#define delete_file prefix(delete_file)
|
|
int delete_file (gfc_unit *);
|
|
|
|
#define file_exists prefix(file_exists)
|
|
int file_exists (void);
|
|
|
|
#define inquire_sequential prefix(inquire_sequential)
|
|
const char *inquire_sequential (const char *, int);
|
|
|
|
#define inquire_direct prefix(inquire_direct)
|
|
const char *inquire_direct (const char *, int);
|
|
|
|
#define inquire_formatted prefix(inquire_formatted)
|
|
const char *inquire_formatted (const char *, int);
|
|
|
|
#define inquire_unformatted prefix(inquire_unformatted)
|
|
const char *inquire_unformatted (const char *, int);
|
|
|
|
#define inquire_read prefix(inquire_read)
|
|
const char *inquire_read (const char *, int);
|
|
|
|
#define inquire_write prefix(inquire_write)
|
|
const char *inquire_write (const char *, int);
|
|
|
|
#define inquire_readwrite prefix(inquire_readwrite)
|
|
const char *inquire_readwrite (const char *, int);
|
|
|
|
#define file_length prefix(file_length)
|
|
gfc_offset file_length (stream *);
|
|
|
|
#define file_position prefix(file_position)
|
|
gfc_offset file_position (stream *);
|
|
|
|
#define is_seekable prefix(is_seekable)
|
|
int is_seekable (stream *);
|
|
|
|
#define empty_internal_buffer prefix(empty_internal_buffer)
|
|
void empty_internal_buffer(stream *);
|
|
|
|
#define flush prefix(flush)
|
|
try flush (stream *);
|
|
|
|
|
|
/* unit.c */
|
|
|
|
#define insert_unit prefix(insert_unix)
|
|
void insert_unit (gfc_unit *);
|
|
|
|
#define close_unit prefix(close_unit)
|
|
int close_unit (gfc_unit *);
|
|
|
|
#define is_internal_unit prefix(is_internal_unit)
|
|
int is_internal_unit (void);
|
|
|
|
#define find_unit prefix(find_unit)
|
|
gfc_unit *find_unit (int);
|
|
|
|
#define get_unit prefix(get_unit)
|
|
gfc_unit *get_unit (int);
|
|
|
|
/* open.c */
|
|
|
|
#define test_endfile prefix(test_endfile)
|
|
void test_endfile (gfc_unit *);
|
|
|
|
#define new_unit prefix(new_unit)
|
|
void new_unit (unit_flags *);
|
|
|
|
/* format.c */
|
|
|
|
#define parse_format prefix(parse_format)
|
|
void parse_format (void);
|
|
|
|
#define next_format prefix(next_format)
|
|
fnode *next_format (void);
|
|
|
|
#define unget_format prefix(unget_format)
|
|
void unget_format (fnode *);
|
|
|
|
#define format_error prefix(format_error)
|
|
void format_error (fnode *, const char *);
|
|
|
|
#define free_fnodes prefix(free_fnodes)
|
|
void free_fnodes (void);
|
|
|
|
/* transfer.c */
|
|
|
|
#define SCRATCH_SIZE 300
|
|
|
|
#define scratch prefix(scratch)
|
|
extern char scratch[];
|
|
|
|
#define type_name prefix(type_name)
|
|
const char *type_name (bt);
|
|
|
|
#define read_block prefix(read_block)
|
|
void *read_block (int *);
|
|
|
|
#define write_block prefix(write_block)
|
|
void *write_block (int);
|
|
|
|
#define transfer_integer prefix(transfer_integer)
|
|
void transfer_integer (void *, int);
|
|
|
|
#define transfer_real prefix(transfer_real)
|
|
void transfer_real (void *, int);
|
|
|
|
#define transfer_logical prefix(transfer_logical)
|
|
void transfer_logical (void *, int);
|
|
|
|
#define transfer_character prefix(transfer_character)
|
|
void transfer_character (void *, int);
|
|
|
|
#define transfer_complex prefix(transfer_complex)
|
|
void transfer_complex (void *, int);
|
|
|
|
#define next_record prefix(next_record)
|
|
void next_record (int);
|
|
|
|
#define st_set_nml_var_int prefix(st_set_nml_var_int)
|
|
void st_set_nml_var_int (void * , char * , int , int );
|
|
|
|
#define st_set_nml_var_float prefix(st_set_nml_var_float)
|
|
void st_set_nml_var_float (void * , char * , int , int );
|
|
|
|
#define st_set_nml_var_char prefix(st_set_nml_var_char)
|
|
void st_set_nml_var_char (void * , char * , int , int );
|
|
|
|
#define st_set_nml_var_complex prefix(st_set_nml_var_complex)
|
|
void st_set_nml_var_complex (void * , char * , int , int );
|
|
|
|
#define st_set_nml_var_log prefix(st_set_nml_var_log)
|
|
void st_set_nml_var_log (void * , char * , int , int );
|
|
|
|
/* read.c */
|
|
|
|
#define set_integer prefix(set_integer)
|
|
void set_integer (void *, int64_t, int);
|
|
|
|
#define max_value prefix(max_value)
|
|
uint64_t max_value (int, int);
|
|
|
|
#define convert_real prefix(convert_real)
|
|
int convert_real (void *, const char *, int);
|
|
|
|
#define read_a prefix(read_a)
|
|
void read_a (fnode *, char *, int);
|
|
|
|
#define read_f prefix(read_f)
|
|
void read_f (fnode *, char *, int);
|
|
|
|
#define read_l prefix(read_l)
|
|
void read_l (fnode *, char *, int);
|
|
|
|
#define read_x prefix(read_x)
|
|
void read_x (fnode *);
|
|
|
|
#define read_radix prefix(read_radix)
|
|
void read_radix (fnode *, char *, int, int);
|
|
|
|
#define read_decimal prefix(read_decimal)
|
|
void read_decimal (fnode *, char *, int);
|
|
|
|
/* list_read.c */
|
|
|
|
#define list_formatted_read prefix(list_formatted_read)
|
|
void list_formatted_read (bt, void *, int);
|
|
|
|
#define finish_list_read prefix(finish_list_read)
|
|
void finish_list_read (void);
|
|
|
|
#define init_at_eol prefix(init_at_eol)
|
|
void init_at_eol();
|
|
|
|
#define namelist_read prefix(namelist_read)
|
|
void namelist_read();
|
|
|
|
#define namelist_write prefix(namelist_write)
|
|
void namelist_write();
|
|
|
|
/* write.c */
|
|
|
|
#define write_a prefix(write_a)
|
|
void write_a (fnode *, const char *, int);
|
|
|
|
#define write_b prefix(write_b)
|
|
void write_b (fnode *, const char *, int);
|
|
|
|
#define write_d prefix(write_d)
|
|
void write_d (fnode *, const char *, int);
|
|
|
|
#define write_e prefix(write_e)
|
|
void write_e (fnode *, const char *, int);
|
|
|
|
#define write_en prefix(write_en)
|
|
void write_en (fnode *, const char *, int);
|
|
|
|
#define write_es prefix(write_es)
|
|
void write_es (fnode *, const char *, int);
|
|
|
|
#define write_f prefix(write_f)
|
|
void write_f (fnode *, const char *, int);
|
|
|
|
#define write_i prefix(write_i)
|
|
void write_i (fnode *, const char *, int);
|
|
|
|
#define write_l prefix(write_l)
|
|
void write_l (fnode *, char *, int);
|
|
|
|
#define write_o prefix(write_o)
|
|
void write_o (fnode *, const char *, int);
|
|
|
|
#define write_x prefix(write_x)
|
|
void write_x (fnode *);
|
|
|
|
#define write_z prefix(write_z)
|
|
void write_z (fnode *, const char *, int);
|
|
|
|
#define list_formatted_write prefix(list_formatted_write)
|
|
void list_formatted_write (bt, void *, int);
|
|
|
|
|
|
#define st_open prefix(st_open)
|
|
#define st_close prefix(st_close)
|
|
#define st_inquire prefix(st_inquire)
|
|
#define st_rewind prefix(st_rewind)
|
|
#define st_read prefix(st_read)
|
|
#define st_read_done prefix(st_read_done)
|
|
#define st_write prefix(st_write)
|
|
#define st_write_done prefix(st_write_done)
|
|
#define st_backspace prefix(st_backspace)
|
|
#define st_endfile prefix(st_endfile)
|
|
|
|
|
|
void __MAIN (void);
|
|
|
|
#endif
|