OSDN Git Service

* io.h: Setting higher default record length.
[pf3gnuchains/gcc-fork.git] / 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