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, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, 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 "/var/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 /* Namelist represent object */
  78 /*
  79    Namelist Records
  80        &groupname  object=value [,object=value].../
  81      or
  82        &groupname  object=value [,object=value]...&groupname
  83
  84   Even more complex, during the execution of a program containing a
  85   namelist READ statement, you can specify a question mark character(?)
  86   or a question mark character preceded by an equal sign(=?) to get
  87   the information of the namelist group. By '?', the name of variables
  88   in the namelist will be displayed, by '=?', the name and value of
  89   variables will be displayed.
  90
  91   All these requirements need a new data structure to record all info
  92   about the namelist.
  93 */
  94
  95 typedef struct namelist_type
  96 {
  97   char * var_name;
  98   void * mem_pos;
  99   int  value_acquired;
 100   int len;
 101   int string_length;
 102   bt type;
 103   struct namelist_type * next;
 104 }
 105 namelist_info;
 106
 107 /* Options for the OPEN statement.  */
 108
 109 typedef enum
 110 { ACCESS_SEQUENTIAL, ACCESS_DIRECT,
 111   ACCESS_UNSPECIFIED
 112 }
 113 unit_access;
 114
 115 typedef enum
 116 { ACTION_READ, ACTION_WRITE, ACTION_READWRITE,
 117   ACTION_UNSPECIFIED
 118 }
 119 unit_action;
 120
 121 typedef enum
 122 { BLANK_NULL, BLANK_ZERO, BLANK_UNSPECIFIED }
 123 unit_blank;
 124
 125 typedef enum
 126 { DELIM_NONE, DELIM_APOSTROPHE, DELIM_QUOTE,
 127   DELIM_UNSPECIFIED
 128 }
 129 unit_delim;
 130
 131 typedef enum
 132 { FORM_FORMATTED, FORM_UNFORMATTED, FORM_UNSPECIFIED }
 133 unit_form;
 134
 135 typedef enum
 136 { POSITION_ASIS, POSITION_REWIND, POSITION_APPEND,
 137   POSITION_UNSPECIFIED
 138 }
 139 unit_position;
 140
 141 typedef enum
 142 { STATUS_UNKNOWN, STATUS_OLD, STATUS_NEW, STATUS_SCRATCH,
 143   STATUS_REPLACE, STATUS_UNSPECIFIED
 144 }
 145 unit_status;
 146
 147 typedef enum
 148 { PAD_YES, PAD_NO, PAD_UNSPECIFIED }
 149 unit_pad;
 150
 151 typedef enum
 152 { ADVANCE_YES, ADVANCE_NO, ADVANCE_UNSPECIFIED }
 153 unit_advance;
 154
 155 typedef enum
 156 {READING, WRITING}
 157 unit_mode;
 158
 159 /* Statement parameters.  These are all the things that can appear in
 160    an I/O statement.  Some are inputs and some are outputs, but none
 161    are both.  All of these values are initially zeroed and are zeroed
 162    at the end of a library statement.  The relevant values need to be
 163    set before entry to an I/O statement.  This structure needs to be
 164    duplicated by the back end.  */
 165
 166 typedef struct
 167 {
 168   GFC_INTEGER_4 unit;
 169   GFC_INTEGER_4 err, end, eor, list_format; /* These are flags, not values.  */
 170
 171 /* Return values from library statements.  These are returned only if
 172    the labels are specified in the statement itself and the condition
 173    occurs.  In most cases, none of the labels are specified and the
 174    return value does not have to be checked.  Must be consistent with
 175    the front end.  */
 176
 177   enum
 178   {
 179     LIBRARY_OK = 0,
 180     LIBRARY_ERROR,
 181     LIBRARY_END,
 182     LIBRARY_EOR
 183   }
 184   library_return;
 185
 186   GFC_INTEGER_4 *iostat, *exist, *opened, *number, *named;
 187   GFC_INTEGER_4 rec;
 188   GFC_INTEGER_4 *nextrec, *size;
 189
 190   GFC_INTEGER_4 recl_in;
 191   GFC_INTEGER_4 *recl_out;
 192
 193   GFC_INTEGER_4 *iolength;
 194
 195 #define CHARACTER(name) \
 196               char * name; \
 197               gfc_charlen_type name ## _len
 198   CHARACTER (file);
 199   CHARACTER (status);
 200   CHARACTER (access);
 201   CHARACTER (form);
 202   CHARACTER (blank);
 203   CHARACTER (position);
 204   CHARACTER (action);
 205   CHARACTER (delim);
 206   CHARACTER (pad);
 207   CHARACTER (format);
 208   CHARACTER (advance);
 209   CHARACTER (name);
 210   CHARACTER (internal_unit);
 211   CHARACTER (sequential);
 212   CHARACTER (direct);
 213   CHARACTER (formatted);
 214   CHARACTER (unformatted);
 215   CHARACTER (read);
 216   CHARACTER (write);
 217   CHARACTER (readwrite);
 218
 219 /* namelist related data */
 220   CHARACTER (namelist_name);
 221   GFC_INTEGER_4 namelist_read_mode;
 222
 223 #undef CHARACTER
 224 }
 225 st_parameter;
 226
 227 extern st_parameter ioparm;
 228 iexport_data_proto(ioparm);
 229
 230 extern namelist_info * ionml;
 231 internal_proto(ionml);
 232
 233 typedef struct
 234 {
 235   unit_access access;
 236   unit_action action;
 237   unit_blank blank;
 238   unit_delim delim;
 239   unit_form form;
 240   int is_notpadded;
 241   unit_position position;
 242   unit_status status;
 243   unit_pad pad;
 244 }
 245 unit_flags;
 246
 247
 248 /* The default value of record length for preconnected units is defined
 249    here. This value can be overriden by an environment variable.
 250    Default value is 1 Gb.  */
 251
 252 #define DEFAULT_RECL 1073741824
 253
 254
 255 typedef struct gfc_unit
 256 {
 257   int unit_number;
 258
 259   stream *s;
 260
 261   struct gfc_unit *left, *right;        /* Treap links.  */
 262   int priority;
 263
 264   int read_bad, current_record;
 265   enum
 266   { NO_ENDFILE, AT_ENDFILE, AFTER_ENDFILE }
 267   endfile;
 268
 269   unit_mode  mode;
 270   unit_flags flags;
 271   gfc_offset recl, last_record, maxrec, bytes_left;
 272
 273   /* recl           -- Record length of the file.
 274      last_record    -- Last record number read or written
 275      maxrec         -- Maximum record number in a direct access file
 276      bytes_left     -- Bytes left in current record.  */
 277
 278   int file_len;
 279   char file[1];       /* Filename is allocated at the end of the structure.  */
 280 }
 281 gfc_unit;
 282
 283 /* Global variables.  Putting these in a structure makes it easier to
 284    maintain, particularly with the constraint of a prefix.  */
 285
 286 typedef struct
 287 {
 288   int in_library;       /* Nonzero if a library call is being processed.  */
 289   int size;     /* Bytes processed by the current data-transfer statement.  */
 290   gfc_offset max_offset;        /* Maximum file offset.  */
 291   int item_count;       /* Item number in a formatted data transfer.  */
 292   int reversion_flag;   /* Format reversion has occurred.  */
 293   int first_item;
 294
 295   gfc_unit *unit_root;
 296   int seen_dollar;
 297
 298   unit_mode  mode;
 299
 300   unit_blank blank_status;
 301   enum {SIGN_S, SIGN_SS, SIGN_SP} sign_status;
 302   int scale_factor;
 303   jmp_buf eof_jump;
 304 }
 305 global_t;
 306
 307 extern global_t g;
 308 internal_proto(g);
 309
 310 extern gfc_unit *current_unit;
 311 internal_proto(current_unit);
 312
 313 /* Format tokens.  Only about half of these can be stored in the
 314    format nodes.  */
 315
 316 typedef enum
 317 {
 318   FMT_NONE = 0, FMT_UNKNOWN, FMT_SIGNED_INT, FMT_ZERO, FMT_POSINT, FMT_PERIOD,
 319   FMT_COMMA, FMT_COLON, FMT_SLASH, FMT_DOLLAR, FMT_T, FMT_TR, FMT_TL,
 320   FMT_LPAREN, FMT_RPAREN, FMT_X, FMT_S, FMT_SS, FMT_SP, FMT_STRING,
 321   FMT_BADSTRING, FMT_P, FMT_I, FMT_B, FMT_BN, FMT_BZ, FMT_O, FMT_Z, FMT_F,
 322   FMT_E, FMT_EN, FMT_ES, FMT_G, FMT_L, FMT_A, FMT_D, FMT_H, FMT_END
 323 }
 324 format_token;
 325
 326
 327 /* Format nodes.  A format string is converted into a tree of these
 328    structures, which is traversed as part of a data transfer statement.  */
 329
 330 typedef struct fnode
 331 {
 332   format_token format;
 333   int repeat;
 334   struct fnode *next;
 335   char *source;
 336
 337   union
 338   {
 339     struct
 340     {
 341       int w, d, e;
 342     }
 343     real;
 344
 345     struct
 346     {
 347       int length;
 348       char *p;
 349     }
 350     string;
 351
 352     struct
 353     {
 354       int w, m;
 355     }
 356     integer;
 357
 358     int w;
 359     int k;
 360     int r;
 361     int n;
 362
 363     struct fnode *child;
 364   }
 365   u;
 366
 367   /* Members for traversing the tree during data transfer.  */
 368
 369   int count;
 370   struct fnode *current;
 371
 372 }
 373 fnode;
 374
 375
 376 /* unix.c */
 377
 378 extern int move_pos_offset (stream *, int);
 379 internal_proto(move_pos_offset);
 380
 381 extern int compare_files (stream *, stream *);
 382 internal_proto(compare_files);
 383
 384 extern stream *init_error_stream (void);
 385 internal_proto(init_error_stream);
 386
 387 extern stream *open_external (unit_flags *);
 388 internal_proto(open_external);
 389
 390 extern stream *open_internal (char *, int);
 391 internal_proto(open_internal);
 392
 393 extern stream *input_stream (void);
 394 internal_proto(input_stream);
 395
 396 extern stream *output_stream (void);
 397 internal_proto(output_stream);
 398
 399 extern stream *error_stream (void);
 400 internal_proto(error_stream);
 401
 402 extern int compare_file_filename (stream *, const char *, int);
 403 internal_proto(compare_file_filename);
 404
 405 extern gfc_unit *find_file (void);
 406 internal_proto(find_file);
 407
 408 extern int stream_at_bof (stream *);
 409 internal_proto(stream_at_bof);
 410
 411 extern int stream_at_eof (stream *);
 412 internal_proto(stream_at_eof);
 413
 414 extern int delete_file (gfc_unit *);
 415 internal_proto(delete_file);
 416
 417 extern int file_exists (void);
 418 internal_proto(file_exists);
 419
 420 extern const char *inquire_sequential (const char *, int);
 421 internal_proto(inquire_sequential);
 422
 423 extern const char *inquire_direct (const char *, int);
 424 internal_proto(inquire_direct);
 425
 426 extern const char *inquire_formatted (const char *, int);
 427 internal_proto(inquire_formatted);
 428
 429 extern const char *inquire_unformatted (const char *, int);
 430 internal_proto(inquire_unformatted);
 431
 432 extern const char *inquire_read (const char *, int);
 433 internal_proto(inquire_read);
 434
 435 extern const char *inquire_write (const char *, int);
 436 internal_proto(inquire_write);
 437
 438 extern const char *inquire_readwrite (const char *, int);
 439 internal_proto(inquire_readwrite);
 440
 441 extern gfc_offset file_length (stream *);
 442 internal_proto(file_length);
 443
 444 extern gfc_offset file_position (stream *);
 445 internal_proto(file_position);
 446
 447 extern int is_seekable (stream *);
 448 internal_proto(is_seekable);
 449
 450 extern void empty_internal_buffer(stream *);
 451 internal_proto(empty_internal_buffer);
 452
 453 extern try flush (stream *);
 454 internal_proto(flush);
 455
 456 extern int unit_to_fd (int);
 457 internal_proto(unit_to_fd);
 458
 459 /* unit.c */
 460
 461 extern void insert_unit (gfc_unit *);
 462 internal_proto(insert_unit);
 463
 464 extern int close_unit (gfc_unit *);
 465 internal_proto(close_unit);
 466
 467 extern int is_internal_unit (void);
 468 internal_proto(is_internal_unit);
 469
 470 extern gfc_unit *find_unit (int);
 471 internal_proto(find_unit);
 472
 473 extern gfc_unit *get_unit (int);
 474 internal_proto(get_unit);
 475
 476 /* open.c */
 477
 478 extern void test_endfile (gfc_unit *);
 479 internal_proto(test_endfile);
 480
 481 extern void new_unit (unit_flags *);
 482 internal_proto(new_unit);
 483
 484 /* format.c */
 485
 486 extern void parse_format (void);
 487 internal_proto(parse_format);
 488
 489 extern fnode *next_format (void);
 490 internal_proto(next_format);
 491
 492 extern void unget_format (fnode *);
 493 internal_proto(unget_format);
 494
 495 extern void format_error (fnode *, const char *);
 496 internal_proto(format_error);
 497
 498 extern void free_fnodes (void);
 499 internal_proto(free_fnodes);
 500
 501 /* transfer.c */
 502
 503 #define SCRATCH_SIZE 300
 504
 505 extern char scratch[];
 506 internal_proto(scratch);
 507
 508 extern const char *type_name (bt);
 509 internal_proto(type_name);
 510
 511 extern void *read_block (int *);
 512 internal_proto(read_block);
 513
 514 extern void *write_block (int);
 515 internal_proto(write_block);
 516
 517 extern void next_record (int);
 518 internal_proto(next_record);
 519
 520 /* read.c */
 521
 522 extern void set_integer (void *, int64_t, int);
 523 internal_proto(set_integer);
 524
 525 extern uint64_t max_value (int, int);
 526 internal_proto(max_value);
 527
 528 extern int convert_real (void *, const char *, int);
 529 internal_proto(convert_real);
 530
 531 extern void read_a (fnode *, char *, int);
 532 internal_proto(read_a);
 533
 534 extern void read_f (fnode *, char *, int);
 535 internal_proto(read_f);
 536
 537 extern void read_l (fnode *, char *, int);
 538 internal_proto(read_l);
 539
 540 extern void read_x (fnode *);
 541 internal_proto(read_x);
 542
 543 extern void read_radix (fnode *, char *, int, int);
 544 internal_proto(read_radix);
 545
 546 extern void read_decimal (fnode *, char *, int);
 547 internal_proto(read_decimal);
 548
 549 /* list_read.c */
 550
 551 extern void list_formatted_read (bt, void *, int);
 552 internal_proto(list_formatted_read);
 553
 554 extern void finish_list_read (void);
 555 internal_proto(finish_list_read);
 556
 557 extern void init_at_eol();
 558 internal_proto(init_at_eol);
 559
 560 extern void namelist_read();
 561 internal_proto(namelist_read);
 562
 563 extern void namelist_write();
 564 internal_proto(namelist_write);
 565
 566 /* write.c */
 567
 568 extern void write_a (fnode *, const char *, int);
 569 internal_proto(write_a);
 570
 571 extern void write_b (fnode *, const char *, int);
 572 internal_proto(write_b);
 573
 574 extern void write_d (fnode *, const char *, int);
 575 internal_proto(write_d);
 576
 577 extern void write_e (fnode *, const char *, int);
 578 internal_proto(write_e);
 579
 580 extern void write_en (fnode *, const char *, int);
 581 internal_proto(write_en);
 582
 583 extern void write_es (fnode *, const char *, int);
 584 internal_proto(write_es);
 585
 586 extern void write_f (fnode *, const char *, int);
 587 internal_proto(write_f);
 588
 589 extern void write_i (fnode *, const char *, int);
 590 internal_proto(write_i);
 591
 592 extern void write_l (fnode *, char *, int);
 593 internal_proto(write_l);
 594
 595 extern void write_o (fnode *, const char *, int);
 596 internal_proto(write_o);
 597
 598 extern void write_x (fnode *);
 599 internal_proto(write_x);
 600
 601 extern void write_z (fnode *, const char *, int);
 602 internal_proto(write_z);
 603
 604 extern void list_formatted_write (bt, void *, int);
 605 internal_proto(list_formatted_write);
 606
 607 #endif