source: libcfa/src/fstream.cfa @ 6065281f

Last change on this file since 6065281f was bbdf954, checked in by Peter A. Buhr <pabuhr@…>, 13 months ago

fix end-of-file bug when checking for I/O errors
  • Property mode set to 100644
File size: 11.2 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// fstream.c --
8//
9// Author           : Peter A. Buhr
10// Created On       : Wed May 27 17:56:53 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Sat Jun 17 08:51:12 2023
13// Update Count     : 528
14//
15
16#include "fstream.hfa"                                                                  // also includes iostream.hfa
17
18#include <stdio.h>                                                                              // vfprintf, vfscanf
19#include <stdlib.h>                                                                             // exit
20#include <stdarg.h>                                                                             // varargs
21#include <string.h>                                                                             // strncpy, strerror
22#include <assert.h>
23#include <errno.h>                                                                              // errno
24
25#pragma GCC visibility push(default)
26
27// *********************************** ofstream ***********************************
28
29
30#define IO_MSG "I/O error: "
31
32// private
33void ?{}( ofstream & os, void * file ) with( os ) {
34        file$ = file;
35        sepDefault$ = true;
36        sepOnOff$ = false;
37        nlOnOff$ = true;
38        prt$ = false;
39        sawNL$ = false;
40        sepSetCur$( os, sepGet( os ) );
41        sepSet( os, " " );
42        sepSetTuple( os, ", " );
43} // ?{}
44
45inline bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
46inline void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
47inline void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
48inline const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
49inline void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
50inline bool getNL$( ofstream & os ) { return os.sawNL$; }
51inline void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
52inline bool getANL$( ofstream & os ) { return os.nlOnOff$; }
53inline bool getPrt$( ofstream & os ) { return os.prt$; }
54inline void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
55
56inline void lock( ofstream & os ) with( os ) { lock( os.lock$ ); }
57inline void unlock( ofstream & os ) { unlock( os.lock$ ); }
58
59// public
60void ?{}( ofstream & os ) { os.file$ = 0p; }
61void ?{}( ofstream & os, const char name[], const char mode[] ) { open( os, name, mode ); }
62void ?{}( ofstream & os, const char name[] ) { open( os, name, "w" ); }
63void ^?{}( ofstream & os ) { close( os ); }
64
65void sepOn( ofstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
66void sepOff( ofstream & os ) { os.sepOnOff$ = false; }
67
68bool sepDisable( ofstream & os ) {
69        bool temp = os.sepDefault$;
70        os.sepDefault$ = false;
71        sepReset$( os );
72        return temp;
73} // sepDisable
74
75bool sepEnable( ofstream & os ) {
76        bool temp = os.sepDefault$;
77        os.sepDefault$ = true;
78        if ( os.sepOnOff$ ) sepReset$( os );                            // start of line ?
79        return temp;
80} // sepEnable
81
82void nlOn( ofstream & os ) { os.nlOnOff$ = true; }
83void nlOff( ofstream & os ) { os.nlOnOff$ = false; }
84
85const char * sepGet( ofstream & os ) { return os.separator$; }
86void sepSet( ofstream & os, const char s[] ) {
87        assert( s );
88        strncpy( os.separator$, s, ofstream_sepSize - 1 );
89        os.separator$[ofstream_sepSize - 1] = '\0';
90} // sepSet
91
92const char * sepGetTuple( ofstream & os ) { return os.tupleSeparator$; }
93void sepSetTuple( ofstream & os, const char s[] ) {
94        assert( s );
95        strncpy( os.tupleSeparator$, s, ofstream_sepSize - 1 );
96        os.tupleSeparator$[ofstream_sepSize - 1] = '\0';
97} // sepSet
98
99void ends( ofstream & os ) {
100        if ( getANL$( os ) ) nl( os );
101        else setPrt$( os, false );                                                      // turn off
102        if ( &os == &exit ) exit( EXIT_FAILURE );
103        if ( &os == &abort ) abort();
104} // ends
105
106bool fail( ofstream & os ) { return os.file$ == 0 || ferror( (FILE *)(os.file$) ); }
107void clear( ofstream & os ) { clearerr( (FILE *)(os.file$) ); }
108int flush( ofstream & os ) { return fflush( (FILE *)(os.file$) ); }
109
110void open( ofstream & os, const char name[], const char mode[] ) {
111        FILE * file;
112    for ( cnt; 10 ) {
113                errno = 0;
114                file = fopen( name, mode );
115          if ( file != 0p || errno != EINTR ) break;            // timer interrupt ?
116          if ( cnt == 9 ) abort( "ofstream open EINTR spinning exceeded" );
117    } // for
118        if ( file == 0p ) {
119                throw (open_failure){ os };
120                // abort | IO_MSG "open output file \"" | name | "\"" | nl | strerror( errno );
121        } // if
122        (os){ file };                                                                           // initialize
123} // open
124
125void open( ofstream & os, const char name[] ) { open( os, name, "w" ); }
126
127void close( ofstream & os ) with( os ) {
128  if ( (FILE *)(file$) == 0p ) return;
129  if ( (FILE *)(file$) == (FILE *)stdout || (FILE *)(file$) == (FILE *)stderr ) return;
130
131        int ret;
132    for ( cnt; 10 ) {
133                errno = 0;
134                ret = fclose( (FILE *)(file$) );
135          if ( ret != EOF || errno != EINTR ) break;            // timer interrupt ?
136          if ( cnt == 9 ) abort( "ofstream open EINTR spinning exceeded" );
137    } // for
138        if ( ret == EOF ) {
139                throw (close_failure){ os };
140                // abort | IO_MSG "close output" | nl | strerror( errno );
141        } // if
142        file$ = 0p;                                                                                     // safety after close
143} // close
144
145ofstream & write( ofstream & os, const char data[], size_t size ) {
146        if ( fail( os ) ) {
147                throw (write_failure){ os };
148                // abort | IO_MSG "attempt write I/O on failed stream";
149        } // if
150
151        if ( fwrite( data, 1, size, (FILE *)(os.file$) ) != size ) {
152                throw (write_failure){ os };
153                // abort | IO_MSG "write" | nl | strerror( errno );
154        } // if
155        return os;
156} // write
157
158int fmt( ofstream & os, const char format[], ... ) {
159        va_list args;
160        va_start( args, format );
161
162        int len;
163    for ( cnt; 10 ) {
164                errno = 0;
165                disable_interrupts();
166                len = vfprintf( (FILE *)(os.file$), format, args );
167                enable_interrupts();
168          if ( len != EOF || errno != EINTR ) break;            // timer interrupt ?
169          if ( cnt == 9 ) abort( "ofstream fmt EINTR spinning exceeded" );
170    } // for
171        if ( len == EOF ) {                                                                     // error writing ?
172                abort | IO_MSG "invalid write";
173        } // if
174        va_end( args );
175
176        setPrt$( os, true );                                                            // called in output cascade
177        sepReset$( os );                                                                        // reset separator
178        return len;
179} // fmt
180
181static ofstream soutFile = { (FILE *)stdout };
182ofstream & sout = soutFile, & stdout = soutFile;
183static ofstream serrFile = { (FILE *)stderr };
184ofstream & serr = serrFile, & stderr = serrFile;
185
186static ofstream lsoutFile = { (FILE *)stdout };
187ofstream & lsout = lsoutFile;
188
189static ofstream exitFile = { (FILE *)stdout };
190ofstream & exit = exitFile;
191static ofstream abortFile = { (FILE *)stderr };
192ofstream & abort = abortFile;
193
194ofstream & nl( ofstream & os ) {
195        nl$( os );                                                                                      // call basic_ostream nl
196        flush( os );
197        return os;
198} // nl
199
200
201// *********************************** ifstream ***********************************
202
203
204// private
205void ?{}( ifstream & is, void * file ) with( is ) {
206        file$ = file;
207        nlOnOff$ = false;
208} // ?{}
209
210bool getANL$( ifstream & os ) { return os.nlOnOff$; }
211
212inline void lock( ifstream & os ) with( os ) { lock( os.lock$ ); }
213inline void unlock( ifstream & os ) { unlock( os.lock$ ); }
214
215// public
216void ?{}( ifstream & is ) { is.file$ = 0p; }
217void ?{}( ifstream & is, const char name[], const char mode[] ) { open( is, name, mode ); }
218void ?{}( ifstream & is, const char name[] ) { open( is, name, "r" ); }
219void ^?{}( ifstream & is ) { close( is ); }
220
221bool fail( ifstream & is ) { return is.file$ == 0p || ferror( (FILE *)(is.file$) ); }
222void clear( ifstream & is ) { clearerr( (FILE *)(is.file$) ); }
223
224void nlOn( ifstream & os ) { os.nlOnOff$ = true; }
225void nlOff( ifstream & os ) { os.nlOnOff$ = false; }
226
227void ends( ifstream & is ) {}
228
229bool eof( ifstream & is ) { return feof( (FILE *)(is.file$) ) != 0; }
230
231void open( ifstream & is, const char name[], const char mode[] ) {
232        FILE * file;
233    for ( cnt; 10 ) {
234                errno = 0;
235                file = fopen( name, mode );
236          if ( file != 0p || errno != EINTR ) break;            // timer interrupt ?
237          if ( cnt == 9 ) abort( "ifstream open EINTR spinning exceeded" );
238    } // for
239        if ( file == 0p ) {
240                throw (open_failure){ is };
241                // abort | IO_MSG "open input file \"" | name | "\"" | nl | strerror( errno );
242        } // if
243        (is){ file };                                                                           // initialize
244} // open
245
246void open( ifstream & is, const char name[] ) { open( is, name, "r" ); }
247
248void close( ifstream & is ) with( is ) {
249  if ( (FILE *)(file$) == 0p ) return;
250  if ( (FILE *)(file$) == (FILE *)stdin ) return;
251
252        int ret;
253    for ( cnt; 10 ) {
254                errno = 0;
255                ret = fclose( (FILE *)(file$) );
256          if ( ret != EOF || errno != EINTR ) break;            // timer interrupt ?
257          if ( cnt == 9 ) abort( "ifstream close EINTR spinning exceeded" );
258    } // for
259        if ( ret == EOF ) {
260                throw (close_failure){ is };
261                // abort | IO_MSG "close input" | nl | strerror( errno );
262        } // if
263        file$ = 0p;                                                                                     // safety after close
264} // close
265
266ifstream & read( ifstream & is, char data[], size_t size ) {
267        if ( fail( is ) ) {
268                throw (read_failure){ is };
269                // abort | IO_MSG "attempt read I/O on failed stream";
270        } // if
271
272        if ( fread( data, size, 1, (FILE *)(is.file$) ) == 0 ) {
273                throw (read_failure){ is };
274                // abort | IO_MSG "read" | nl | strerror( errno );
275        } // if
276        return is;
277} // read
278
279ifstream &ungetc( ifstream & is, char c ) {
280        if ( fail( is ) ) {
281                abort | IO_MSG "attempt ungetc I/O on failed stream";
282        } // if
283
284        if ( ungetc( c, (FILE *)(is.file$) ) == EOF ) {
285                abort | IO_MSG "ungetc" | nl | strerror( errno );
286        } // if
287        return is;
288} // ungetc
289
290int fmt( ifstream & is, const char format[], ... ) {
291        va_list args;
292        va_start( args, format );
293
294        int len;
295    for () {                                                                                    // no check for EINTR limit waiting for keyboard input
296                errno = 0;
297                disable_interrupts();
298                len = vfscanf( (FILE *)(is.file$), format, args );
299                enable_interrupts();
300          if ( len != EOF || errno != EINTR ) break;            // timer interrupt ?
301    } // for
302        if ( len == EOF ) {                                                                     // EOF or matching failure ?
303                if ( ! feof( (FILE *)(is.file$) ) && ferror( (FILE *)(is.file$) ) ) {
304                        abort | IO_MSG "invalid read";
305                } // if
306        } // if
307        va_end( args );
308        return len;
309} // fmt
310
311static ifstream sinFile = { (FILE *)stdin };
312ifstream & sin = sinFile, & stdin = sinFile;
313
314
315// *********************************** exceptions ***********************************
316
317
318static vtable(open_failure) open_failure_vt;
319
320// exception I/O constructors
321void ?{}( open_failure & ex, ofstream & ostream ) with(ex) {
322        virtual_table = &open_failure_vt;
323        ostream = &ostream;
324        tag = 1;
325} // ?{}
326
327void ?{}( open_failure & ex, ifstream & istream ) with(ex) {
328        virtual_table = &open_failure_vt;
329        istream = &istream;
330        tag = 0;
331} // ?{}
332
333
334static vtable(close_failure) close_failure_vt;
335
336// exception I/O constructors
337void ?{}( close_failure & ex, ofstream & ostream ) with(ex) {
338        virtual_table = &close_failure_vt;
339        ostream = &ostream;
340        tag = 1;
341} // ?{}
342
343void ?{}( close_failure & ex, ifstream & istream ) with(ex) {
344        virtual_table = &close_failure_vt;
345        istream = &istream;
346        tag = 0;
347} // ?{}
348
349
350static vtable(write_failure) write_failure_vt;
351
352// exception I/O constructors
353void ?{}( write_failure & ex, ofstream & ostream ) with(ex) {
354        virtual_table = &write_failure_vt;
355        ostream = &ostream;
356        tag = 1;
357} // ?{}
358
359void ?{}( write_failure & ex, ifstream & istream ) with(ex) {
360        virtual_table = &write_failure_vt;
361        istream = &istream;
362        tag = 0;
363} // ?{}
364
365
366static vtable(read_failure) read_failure_vt;
367
368// exception I/O constructors
369void ?{}( read_failure & ex, ofstream & ostream ) with(ex) {
370        virtual_table = &read_failure_vt;
371        ostream = &ostream;
372        tag = 1;
373} // ?{}
374
375void ?{}( read_failure & ex, ifstream & istream ) with(ex) {
376        virtual_table = &read_failure_vt;
377        istream = &istream;
378        tag = 0;
379} // ?{}
380
381// void throwopen_failure( ofstream & ostream ) {
382//      open_failure exc = { ostream };
383// }
384
385// void throwopen_failure( ifstream & istream ) {
386//      open_failure exc = { istream };
387// }
388
389// Local Variables: //
390// tab-width: 4 //
391// End: //
Note: See TracBrowser for help on using the repository browser.