libgfortran/io/io.h

   1 /* Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   2    Contributed by Andy Vaught
   3
   4 This file is part of the GNU Fortran 95 runtime library (libgfortran).
   5
   6 Libgfortran is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 Libgfortran is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with Libgfortran; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  19 Boston, MA 02110-1301, USA.  */
  20
  21 /* As a special exception, if you link this library with other files,
  22    some of which are compiled with GCC, to produce an executable,
  23    this library does not by itself cause the resulting executable
  24    to be covered by the GNU General Public License.
  25    This exception does not however invalidate any other reasons why
  26    the executable file might be covered by the GNU General Public License.  */
  27
  28 #ifndef GFOR_IO_H
  29 #define GFOR_IO_H
  30
  31 /* IO library include.  */
  32
  33 #include <setjmp.h>
  34 #include "libgfortran.h"
  35
  36 #define DEFAULT_TEMPDIR "/tmp"
  37
  38 /* Basic types used in data transfers.  */
  39
  40 typedef enum
  41 { BT_NULL, BT_INTEGER, BT_LOGICAL, BT_CHARACTER, BT_REAL,
  42   BT_COMPLEX
  43 }
  44 bt;
  45
  46
  47 typedef enum
  48 { SUCCESS = 1, FAILURE }
  49 try;
  50
  51 typedef struct stream
  52 {
  53   char *(*alloc_w_at) (struct stream *, int *, gfc_offset);
  54   char *(*alloc_r_at) (struct stream *, int *, gfc_offset);
  55   try (*sfree) (struct stream *);
  56   try (*close) (struct stream *);
  57   try (*seek) (struct stream *, gfc_offset);
  58   try (*truncate) (struct stream *);
  59 }
  60 stream;
  61
  62
  63 /* Macros for doing file I/O given a stream.  */
  64
  65 #define sfree(s) ((s)->sfree)(s)
  66 #define sclose(s) ((s)->close)(s)
  67
  68 #define salloc_r(s, len) ((s)->alloc_r_at)(s, len, -1)
  69 #define salloc_w(s, len) ((s)->alloc_w_at)(s, len, -1)
  70
  71 #define salloc_r_at(s, len, where) ((s)->alloc_r_at)(s, len, where)
  72 #define salloc_w_at(s, len, where) ((s)->alloc_w_at)(s, len, where)
  73
  74 #define sseek(s, pos) ((s)->seek)(s, pos)
  75 #define struncate(s) ((s)->truncate)(s)
  76
  77 /* Representation of a namelist object in libgfortran
  78
  79    Namelist Records
  80       &GROUPNAME  OBJECT=value[s] [,OBJECT=value[s]].../
  81      or
  82       &GROUPNAME  OBJECT=value[s] [,OBJECT=value[s]]...&END
  83
  84    The object can be a fully qualified, compound name for an instrinsic
  85    type, derived types or derived type components.  So, a substring
  86    a(:)%b(4)%ch(2:4)(1:7) has to be treated correctly in namelist
  87    read. Hence full information about the structure of the object has
  88    to be available to list_read.c and write.
  89
  90    These requirements are met by the following data structures.
  91
  92    nml_loop_spec contains the variables for the loops over index ranges
  93    that are encountered.  Since the variables can be negative, ssize_t
  94    is used.  */
  95
  96 typedef struct nml_loop_spec
  97 {
  98
  99   /* Index counter for this dimension.  */
 100   ssize_t idx;
 101
 102   /* Start for the index counter.  */
 103   ssize_t start;
 104
 105   /* End for the index counter.  */
 106   ssize_t end;
 107
 108   /* Step for the index counter.  */
 109   ssize_t step;
 110 }
 111 nml_loop_spec;
 112
 113 /* namelist_info type contains all the scalar information about the
 114    object and arrays of descriptor_dimension and nml_loop_spec types for
 115    arrays.  */
 116
 117 typedef struct namelist_type
 118 {
 119
 120   /* Object type, stored as GFC_DTYPE_xxxx.  */
 121   bt type;
 122
 123   /* Object name.  */
 124   char * var_name;
 125
 126   /* Address for the start of the object's data.  */
 127   void * mem_pos;
 128
 129   /* Flag to show that a read is to be attempted for this node.  */
 130   int touched;
 131
 132   /* Length of intrinsic type in bytes.  */
 133   int len;
 134
 135   /* Rank of the object.  */
 136   int var_rank;
 137
 138   /* Overall size of the object in bytes.  */
 139   index_type size;
 140
 141   /* Length of character string.  */
 142   index_type string_length;
 143
 144   descriptor_dimension * dim;
 145   nml_loop_spec * ls;
 146   struct namelist_type * next;
 147 }
 148 namelist_info;
 149
 150 /* Options for the OPEN statement.  */
 151
 152 typedef enum
 153 { ACCESS_SEQUENTIAL, ACCESS_DIRECT,
 154   ACCESS_UNSPECIFIED
 155 }
 156 unit_access;
 157
 158 typedef enum
 159 { ACTION_READ, ACTION_WRITE, ACTION_READWRITE,
 160   ACTION_UNSPECIFIED
 161 }
 162 unit_action;
 163
 164 typedef enum
 165 { BLANK_NULL, BLANK_ZERO, BLANK_UNSPECIFIED }
 166 unit_blank;
 167
 168 typedef enum
 169 { DELIM_NONE, DELIM_APOSTROPHE, DELIM_QUOTE,
 170   DELIM_UNSPECIFIED
 171 }
 172 unit_delim;
 173
 174 typedef enum
 175 { FORM_FORMATTED, FORM_UNFORMATTED, FORM_UNSPECIFIED }
 176 unit_form;
 177
 178 typedef enum
 179 { POSITION_ASIS, POSITION_REWIND, POSITION_APPEND,
 180   POSITION_UNSPECIFIED
 181 }
 182 unit_position;
 183
 184 typedef enum
 185 { STATUS_UNKNOWN, STATUS_OLD, STATUS_NEW, STATUS_SCRATCH,
 186   STATUS_REPLACE, STATUS_UNSPECIFIED
 187 }
 188 unit_status;
 189
 190 typedef enum
 191 { PAD_YES, PAD_NO, PAD_UNSPECIFIED }
 192 unit_pad;
 193
 194 typedef enum
 195 { ADVANCE_YES, ADVANCE_NO, ADVANCE_UNSPECIFIED }
 196 unit_advance;
 197
 198 typedef enum
 199 {READING, WRITING}
 200 unit_mode;
 201
 202 /* Statement parameters.  These are all the things that can appear in
 203    an I/O statement.  Some are inputs and some are outputs, but none
 204    are both.  All of these values are initially zeroed and are zeroed
 205    at the end of a library statement.  The relevant values need to be
 206    set before entry to an I/O statement.  This structure needs to be
 207    duplicated by the back end.  */
 208
 209 typedef struct
 210 {
 211   GFC_INTEGER_4 unit;
 212   GFC_INTEGER_4 err, end, eor, list_format; /* These are flags, not values.  */
 213
 214 /* Return values from library statements.  These are returned only if
 215    the labels are specified in the statement itself and the condition
 216    occurs.  In most cases, none of the labels are specified and the
 217    return value does not have to be checked.  Must be consistent with
 218    the front end.  */
 219
 220   enum
 221   {
 222     LIBRARY_OK = 0,
 223     LIBRARY_ERROR,
 224     LIBRARY_END,
 225     LIBRARY_EOR
 226   }
 227   library_return;
 228
 229   GFC_INTEGER_4 *iostat, *exist, *opened, *number, *named;
 230   GFC_INTEGER_4 rec;
 231   GFC_INTEGER_4 *nextrec, *size;
 232
 233   GFC_INTEGER_4 recl_in;
 234   GFC_INTEGER_4 *recl_out;
 235
 236   GFC_INTEGER_4 *iolength;
 237
 238 #define CHARACTER(name) \
 239               char * name; \
 240               gfc_charlen_type name ## _len
 241   CHARACTER (file);
 242   CHARACTER (status);
 243   CHARACTER (access);
 244   CHARACTER (form);
 245   CHARACTER (blank);
 246   CHARACTER (position);
 247   CHARACTER (action);
 248   CHARACTER (delim);
 249   CHARACTER (pad);
 250   CHARACTER (format);
 251   CHARACTER (advance);
 252   CHARACTER (name);
 253   CHARACTER (internal_unit);
 254   CHARACTER (sequential);
 255   CHARACTER (direct);
 256   CHARACTER (formatted);
 257   CHARACTER (unformatted);
 258   CHARACTER (read);
 259   CHARACTER (write);
 260   CHARACTER (readwrite);
 261
 262 /* namelist related data */
 263   CHARACTER (namelist_name);
 264   GFC_INTEGER_4 namelist_read_mode;
 265
 266   /* iomsg */
 267   CHARACTER (iomsg);
 268
 269 #undef CHARACTER
 270 }
 271 st_parameter;
 272
 273 extern st_parameter ioparm;
 274 iexport_data_proto(ioparm);
 275
 276 extern namelist_info * ionml;
 277 internal_proto(ionml);
 278
 279 typedef struct
 280 {
 281   unit_access access;
 282   unit_action action;
 283   unit_blank blank;
 284   unit_delim delim;
 285   unit_form form;
 286   int is_notpadded;
 287   unit_position position;
 288   unit_status status;
 289   unit_pad pad;
 290 }
 291 unit_flags;
 292
 293
 294 /* The default value of record length for preconnected units is defined
 295    here. This value can be overriden by an environment variable.
 296    Default value is 1 Gb.  */
 297
 298 #define DEFAULT_RECL 1073741824
 299
 300
 301 typedef struct gfc_unit
 302 {
 303   int unit_number;
 304
 305   stream *s;
 306
 307   struct gfc_unit *left, *right;        /* Treap links.  */
 308   int priority;
 309
 310   int read_bad, current_record;
 311   enum
 312   { NO_ENDFILE, AT_ENDFILE, AFTER_ENDFILE }
 313   endfile;
 314
 315   unit_mode  mode;
 316   unit_flags flags;
 317   gfc_offset recl, last_record, maxrec, bytes_left;
 318
 319   /* recl           -- Record length of the file.
 320      last_record    -- Last record number read or written
 321      maxrec         -- Maximum record number in a direct access file
 322      bytes_left     -- Bytes left in current record.  */
 323
 324   int file_len;
 325   char file[1];       /* Filename is allocated at the end of the structure.  */
 326 }
 327 gfc_unit;
 328
 329 /* Global variables.  Putting these in a structure makes it easier to
 330    maintain, particularly with the constraint of a prefix.  */
 331
 332 typedef struct
 333 {
 334   int in_library;       /* Nonzero if a library call is being processed.  */
 335   int size;     /* Bytes processed by the current data-transfer statement.  */
 336   gfc_offset max_offset;        /* Maximum file offset.  */
 337   int item_count;       /* Item number in a formatted data transfer.  */
 338   int reversion_flag;   /* Format reversion has occurred.  */
 339   int first_item;
 340
 341   gfc_unit *unit_root;
 342   int seen_dollar;
 343
 344   unit_mode  mode;
 345
 346   unit_blank blank_status;
 347   enum {SIGN_S, SIGN_SS, SIGN_SP} sign_status;
 348   int scale_factor;
 349   jmp_buf eof_jump;
 350 }
 351 global_t;
 352
 353 extern global_t g;
 354 internal_proto(g);
 355
 356 extern gfc_unit *current_unit;
 357 internal_proto(current_unit);
 358
 359 /* Format tokens.  Only about half of these can be stored in the
 360    format nodes.  */
 361
 362 typedef enum
 363 {
 364   FMT_NONE = 0, FMT_UNKNOWN, FMT_SIGNED_INT, FMT_ZERO, FMT_POSINT, FMT_PERIOD,
 365   FMT_COMMA, FMT_COLON, FMT_SLASH, FMT_DOLLAR, FMT_T, FMT_TR, FMT_TL,
 366   FMT_LPAREN, FMT_RPAREN, FMT_X, FMT_S, FMT_SS, FMT_SP, FMT_STRING,
 367   FMT_BADSTRING, FMT_P, FMT_I, FMT_B, FMT_BN, FMT_BZ, FMT_O, FMT_Z, FMT_F,
 368   FMT_E, FMT_EN, FMT_ES, FMT_G, FMT_L, FMT_A, FMT_D, FMT_H, FMT_END
 369 }
 370 format_token;
 371
 372
 373 /* Format nodes.  A format string is converted into a tree of these
 374    structures, which is traversed as part of a data transfer statement.  */
 375
 376 typedef struct fnode
 377 {
 378   format_token format;
 379   int repeat;
 380   struct fnode *next;
 381   char *source;
 382
 383   union
 384   {
 385     struct
 386     {
 387       int w, d, e;
 388     }
 389     real;
 390
 391     struct
 392     {
 393       int length;
 394       char *p;
 395     }
 396     string;
 397
 398     struct
 399     {
 400       int w, m;
 401     }
 402     integer;
 403
 404     int w;
 405     int k;
 406     int r;
 407     int n;
 408
 409     struct fnode *child;
 410   }
 411   u;
 412
 413   /* Members for traversing the tree during data transfer.  */
 414
 415   int count;
 416   struct fnode *current;
 417
 418 }
 419 fnode;
 420
 421
 422 /* unix.c */
 423
 424 extern int move_pos_offset (stream *, int);
 425 internal_proto(move_pos_offset);
 426
 427 extern int compare_files (stream *, stream *);
 428 internal_proto(compare_files);
 429
 430 extern stream *init_error_stream (void);
 431 internal_proto(init_error_stream);
 432
 433 extern stream *open_external (unit_flags *);
 434 internal_proto(open_external);
 435
 436 extern stream *open_internal (char *, int);
 437 internal_proto(open_internal);
 438
 439 extern stream *input_stream (void);
 440 internal_proto(input_stream);
 441
 442 extern stream *output_stream (void);
 443 internal_proto(output_stream);
 444
 445 extern stream *error_stream (void);
 446 internal_proto(error_stream);
 447
 448 extern int compare_file_filename (stream *, const char *, int);
 449 internal_proto(compare_file_filename);
 450
 451 extern gfc_unit *find_file (void);
 452 internal_proto(find_file);
 453
 454 extern int stream_at_bof (stream *);
 455 internal_proto(stream_at_bof);
 456
 457 extern int stream_at_eof (stream *);
 458 internal_proto(stream_at_eof);
 459
 460 extern int delete_file (gfc_unit *);
 461 internal_proto(delete_file);
 462
 463 extern int file_exists (void);
 464 internal_proto(file_exists);
 465
 466 extern const char *inquire_sequential (const char *, int);
 467 internal_proto(inquire_sequential);
 468
 469 extern const char *inquire_direct (const char *, int);
 470 internal_proto(inquire_direct);
 471
 472 extern const char *inquire_formatted (const char *, int);
 473 internal_proto(inquire_formatted);
 474
 475 extern const char *inquire_unformatted (const char *, int);
 476 internal_proto(inquire_unformatted);
 477
 478 extern const char *inquire_read (const char *, int);
 479 internal_proto(inquire_read);
 480
 481 extern const char *inquire_write (const char *, int);
 482 internal_proto(inquire_write);
 483
 484 extern const char *inquire_readwrite (const char *, int);
 485 internal_proto(inquire_readwrite);
 486
 487 extern gfc_offset file_length (stream *);
 488 internal_proto(file_length);
 489
 490 extern gfc_offset file_position (stream *);
 491 internal_proto(file_position);
 492
 493 extern int is_seekable (stream *);
 494 internal_proto(is_seekable);
 495
 496 extern int is_preconnected (stream *);
 497 internal_proto(is_preconnected);
 498
 499 extern void empty_internal_buffer(stream *);
 500 internal_proto(empty_internal_buffer);
 501
 502 extern try flush (stream *);
 503 internal_proto(flush);
 504
 505 extern int stream_isatty (stream *);
 506 internal_proto(stream_isatty);
 507
 508 extern char * stream_ttyname (stream *);
 509 internal_proto(stream_ttyname);
 510
 511 extern int unit_to_fd (int);
 512 internal_proto(unit_to_fd);
 513
 514 extern int unpack_filename (char *, const char *, int);
 515 internal_proto(unpack_filename);
 516
 517 /* unit.c */
 518
 519 extern void insert_unit (gfc_unit *);
 520 internal_proto(insert_unit);
 521
 522 extern int close_unit (gfc_unit *);
 523 internal_proto(close_unit);
 524
 525 extern int is_internal_unit (void);
 526 internal_proto(is_internal_unit);
 527
 528 extern gfc_unit *find_unit (int);
 529 internal_proto(find_unit);
 530
 531 extern gfc_unit *get_unit (int);
 532 internal_proto(get_unit);
 533
 534 /* open.c */
 535
 536 extern void test_endfile (gfc_unit *);
 537 internal_proto(test_endfile);
 538
 539 extern void new_unit (unit_flags *);
 540 internal_proto(new_unit);
 541
 542 /* format.c */
 543
 544 extern void parse_format (void);
 545 internal_proto(parse_format);
 546
 547 extern fnode *next_format (void);
 548 internal_proto(next_format);
 549
 550 extern void unget_format (fnode *);
 551 internal_proto(unget_format);
 552
 553 extern void format_error (fnode *, const char *);
 554 internal_proto(format_error);
 555
 556 extern void free_fnodes (void);
 557 internal_proto(free_fnodes);
 558
 559 /* transfer.c */
 560
 561 #define SCRATCH_SIZE 300
 562
 563 extern char scratch[];
 564 internal_proto(scratch);
 565
 566 extern const char *type_name (bt);
 567 internal_proto(type_name);
 568
 569 extern void *read_block (int *);
 570 internal_proto(read_block);
 571
 572 extern void *write_block (int);
 573 internal_proto(write_block);
 574
 575 extern void next_record (int);
 576 internal_proto(next_record);
 577
 578 /* read.c */
 579
 580 extern void set_integer (void *, GFC_INTEGER_LARGEST, int);
 581 internal_proto(set_integer);
 582
 583 extern GFC_UINTEGER_LARGEST max_value (int, int);
 584 internal_proto(max_value);
 585
 586 extern int convert_real (void *, const char *, int);
 587 internal_proto(convert_real);
 588
 589 extern void read_a (fnode *, char *, int);
 590 internal_proto(read_a);
 591
 592 extern void read_f (fnode *, char *, int);
 593 internal_proto(read_f);
 594
 595 extern void read_l (fnode *, char *, int);
 596 internal_proto(read_l);
 597
 598 extern void read_x (int);
 599 internal_proto(read_x);
 600
 601 extern void read_radix (fnode *, char *, int, int);
 602 internal_proto(read_radix);
 603
 604 extern void read_decimal (fnode *, char *, int);
 605 internal_proto(read_decimal);
 606
 607 /* list_read.c */
 608
 609 extern void list_formatted_read (bt, void *, int);
 610 internal_proto(list_formatted_read);
 611
 612 extern void finish_list_read (void);
 613 internal_proto(finish_list_read);
 614
 615 extern void init_at_eol (void);
 616 internal_proto(init_at_eol);
 617
 618 extern void namelist_read (void);
 619 internal_proto(namelist_read);
 620
 621 extern void namelist_write (void);
 622 internal_proto(namelist_write);
 623
 624 /* write.c */
 625
 626 extern void write_a (fnode *, const char *, int);
 627 internal_proto(write_a);
 628
 629 extern void write_b (fnode *, const char *, int);
 630 internal_proto(write_b);
 631
 632 extern void write_d (fnode *, const char *, int);
 633 internal_proto(write_d);
 634
 635 extern void write_e (fnode *, const char *, int);
 636 internal_proto(write_e);
 637
 638 extern void write_en (fnode *, const char *, int);
 639 internal_proto(write_en);
 640
 641 extern void write_es (fnode *, const char *, int);
 642 internal_proto(write_es);
 643
 644 extern void write_f (fnode *, const char *, int);
 645 internal_proto(write_f);
 646
 647 extern void write_i (fnode *, const char *, int);
 648 internal_proto(write_i);
 649
 650 extern void write_l (fnode *, char *, int);
 651 internal_proto(write_l);
 652
 653 extern void write_o (fnode *, const char *, int);
 654 internal_proto(write_o);
 655
 656 extern void write_x (int, int);
 657 internal_proto(write_x);
 658
 659 extern void write_z (fnode *, const char *, int);
 660 internal_proto(write_z);
 661
 662 extern void list_formatted_write (bt, void *, int);
 663 internal_proto(list_formatted_write);
 664
 665 /* error.c */
 666 extern try notify_std (int, const char *);
 667 internal_proto(notify_std);
 668
 669 #endif