source: libcfa/src/fstream.cfa @ 7ce2483

ADTast-experimentalenumforall-pointer-decaypthread-emulationqualifiedEnum
Last change on this file since 7ce2483 was 7ce2483, checked in by Peter A. Buhr <pabuhr@…>, 2 years ago

formatting, remove release, and update lock/unlock for use with mutex statement

  • Property mode set to 100644
File size: 10.8 KB
RevLine 
[86bd7c1f]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//
[356189a]7// fstream.c --
[86bd7c1f]8//
[90c3b1c]9// Author           : Peter A. Buhr
[86bd7c1f]10// Created On       : Wed May 27 17:56:53 2015
[5d125e4]11// Last Modified By : Peter A. Buhr
[7ce2483]12// Last Modified On : Fri Oct  1 08:10:21 2021
13// Update Count     : 473
[86bd7c1f]14//
15
[f451177]16#include "fstream.hfa"                                                                  // also includes iostream.hfa
[51b7345]17
[90c3b1c]18#include <stdio.h>                                                                              // vfprintf, vfscanf
19#include <stdlib.h>                                                                             // exit
20#include <stdarg.h>                                                                             // varargs
[b431515]21#include <string.h>                                                                             // strncpy, strerror
[91c389a]22#include <assert.h>
[8a25be9]23#include <errno.h>                                                                              // errno
[51b7345]24
[8d321f9]25// *********************************** ofstream ***********************************
[65240bb]26
27
[53ba273]28#define IO_MSG "I/O error: "
[6ba0659]29
[7ce2483]30// private
31void ?{}( ofstream & os, void * file ) with( os ) {
[3bf3b6b]32        file$ = file;
33        sepDefault$ = true;
34        sepOnOff$ = false;
35        nlOnOff$ = true;
36        prt$ = false;
37        sawNL$ = false;
38        acquired$ = false;
[6c5d92f]39        sepSetCur$( os, sepGet( os ) );
[5cb2b8c]40        sepSet( os, " " );
41        sepSetTuple( os, ", " );
[65240bb]42} // ?{}
[0583064b]43
[7ce2483]44inline bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
45inline void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
46inline void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
47inline const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
48inline void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
49inline bool getNL$( ofstream & os ) { return os.sawNL$; }
50inline void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
51inline bool getANL$( ofstream & os ) { return os.nlOnOff$; }
52inline bool getPrt$( ofstream & os ) { return os.prt$; }
53inline void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
54
55inline void lock( ofstream & os ) with( os ) {  lock( os.lock$ ); }
56inline void unlock( ofstream & os ) { unlock( os.lock$ ); }
[829c907]57
[9ebd778]58// public
[6c5d92f]59void ?{}( ofstream & os ) { os.file$ = 0p; }
[7ce2483]60void ?{}( ofstream & os, const char name[], const char mode[] ) { open( os, name, mode ); }
61void ?{}( ofstream & os, const char name[] ) { open( os, name, "w" ); }
62void ^?{}( ofstream & os ) { close( os ); }
[4cae032]63
[6c5d92f]64void sepOn( ofstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
65void sepOff( ofstream & os ) { os.sepOnOff$ = false; }
[09687aa]66
[93c2e0a]67bool sepDisable( ofstream & os ) {
[6c5d92f]68        bool temp = os.sepDefault$;
69        os.sepDefault$ = false;
70        sepReset$( os );
[53ba273]71        return temp;
72} // sepDisable
[6152c81]73
[93c2e0a]74bool sepEnable( ofstream & os ) {
[6c5d92f]75        bool temp = os.sepDefault$;
76        os.sepDefault$ = true;
77        if ( os.sepOnOff$ ) sepReset$( os );                            // start of line ?
[53ba273]78        return temp;
79} // sepEnable
[90c3b1c]80
[6c5d92f]81void nlOn( ofstream & os ) { os.nlOnOff$ = true; }
82void nlOff( ofstream & os ) { os.nlOnOff$ = false; }
[200fcb3]83
[6c5d92f]84const char * sepGet( ofstream & os ) { return os.separator$; }
[e3fea42]85void sepSet( ofstream & os, const char s[] ) {
[9ebd778]86        assert( s );
[b431515]87        strncpy( os.separator$, s, ofstream_sepSize - 1 );
88        os.separator$[ofstream_sepSize - 1] = '\0';
[9ebd778]89} // sepSet
90
[6c5d92f]91const char * sepGetTuple( ofstream & os ) { return os.tupleSeparator$; }
[e3fea42]92void sepSetTuple( ofstream & os, const char s[] ) {
[9ebd778]93        assert( s );
[b431515]94        strncpy( os.tupleSeparator$, s, ofstream_sepSize - 1 );
95        os.tupleSeparator$[ofstream_sepSize - 1] = '\0';
[9ebd778]96} // sepSet
97
[65240bb]98void ends( ofstream & os ) {
[6c5d92f]99        if ( getANL$( os ) ) nl( os );
100        else setPrt$( os, false );                                                      // turn off
[65240bb]101        if ( &os == &exit ) exit( EXIT_FAILURE );
102        if ( &os == &abort ) abort();
[7ce2483]103        if ( os.acquired$ ) { os.acquired$ = false; unlock( os ); }
[65240bb]104} // ends
105
[7ce2483]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$) ); }
[6ba0659]109
[e3fea42]110void open( ofstream & os, const char name[], const char mode[] ) {
[5cb2b8c]111        FILE * file = fopen( name, mode );
[d1a9ff5]112        if ( file == 0p ) {
[8d321f9]113                throw (Open_Failure){ os };
114                // abort | IO_MSG "open output file \"" | name | "\"" | nl | strerror( errno );
[93c2e0a]115        } // if
[3bf3b6b]116        (os){ file };                                                                           // initialize
[6ba0659]117} // open
118
[7ce2483]119void open( ofstream & os, const char name[] ) { open( os, name, "w" ); }
[8da74119]120
[7ce2483]121void close( ofstream & os ) with( os ) {
[3bf3b6b]122  if ( (FILE *)(file$) == 0p ) return;
123  if ( (FILE *)(file$) == (FILE *)stdout || (FILE *)(file$) == (FILE *)stderr ) return;
[6ba0659]124
[3bf3b6b]125        if ( fclose( (FILE *)(file$) ) == EOF ) {
[ba0d2ea]126                throw (Close_Failure){ os };
127                // abort | IO_MSG "close output" | nl | strerror( errno );
[356189a]128        } // if
[7ce2483]129        file$ = 0p;                                                                                     // safety after close
[6ba0659]130} // close
131
[e3fea42]132ofstream & write( ofstream & os, const char data[], size_t size ) {
[6ba0659]133        if ( fail( os ) ) {
[ba0d2ea]134                throw (Write_Failure){ os };
135                // abort | IO_MSG "attempt write I/O on failed stream";
[6ba0659]136        } // if
137
[6c5d92f]138        if ( fwrite( data, 1, size, (FILE *)(os.file$) ) != size ) {
[ba0d2ea]139                throw (Write_Failure){ os };
140                // abort | IO_MSG "write" | nl | strerror( errno );
[839ccbb]141        } // if
[86bd7c1f]142        return os;
[839ccbb]143} // write
[51b7345]144
[09687aa]145int fmt( ofstream & os, const char format[], ... ) {
[5d125e4]146        va_list args;
[829c907]147        va_start( args, format );
[6c5d92f]148        int len = vfprintf( (FILE *)(os.file$), format, args );
[90c3b1c]149        if ( len == EOF ) {
[6c5d92f]150                if ( ferror( (FILE *)(os.file$) ) ) {
[ff2a33e]151                        abort | IO_MSG "invalid write";
[90c3b1c]152                } // if
153        } // if
[5d125e4]154        va_end( args );
[b72bad4f]155
[6c5d92f]156        setPrt$( os, true );                                                            // called in output cascade
157        sepReset$( os );                                                                        // reset separator
[90c3b1c]158        return len;
[829c907]159} // fmt
160
[7ce2483]161void acquire( ofstream & os ) with( os ) {
162        lock( os );                                                                                     // may increase recursive lock
[3bf3b6b]163        if ( ! acquired$ ) acquired$ = true;                            // not locked ?
[7ce2483]164        else unlock( os );                                                                      // unwind recursive lock at start
[e474cf09]165} // acquire
166
[7ce2483]167void ?{}( osacquire & acq, ofstream & os ) { &acq.os = &os; lock( os ); }
168void ^?{}( osacquire & acq ) { unlock( acq.os ); }
[e474cf09]169
[fd8f88f]170static ofstream soutFile = { (FILE *)stdout };
[a87d40b]171ofstream & sout = soutFile, & stdout = soutFile;
[fd8f88f]172static ofstream serrFile = { (FILE *)stderr };
[a87d40b]173ofstream & serr = serrFile, & stderr = serrFile;
[51b7345]174
[e474cf09]175static ofstream lsoutFile = { (FILE *)stdout };
176ofstream & lsout = lsoutFile;
177
[fd8f88f]178static ofstream exitFile = { (FILE *)stdout };
[65240bb]179ofstream & exit = exitFile;
[fd8f88f]180static ofstream abortFile = { (FILE *)stderr };
[65240bb]181ofstream & abort = abortFile;
[5cb2b8c]182
[f451177]183ofstream & nl( ofstream & os ) {
184        nl$( os );                                                                                      // call basic_ostream nl
185        flush( os );
186        return os;
187} // nl
[90c3b1c]188
[00e9be9]189
[8d321f9]190// *********************************** ifstream ***********************************
[65240bb]191
[51b7345]192
[09687aa]193// private
[7ce2483]194void ?{}( ifstream & is, void * file ) with( is ) {
[3bf3b6b]195        file$ = file;
196        nlOnOff$ = false;
197        acquired$ = false;
[65240bb]198} // ?{}
[09687aa]199
[7ce2483]200inline void lock( ifstream & os ) with( os ) { lock( os.lock$ ); }
201inline void unlock( ifstream & os ) { unlock( os.lock$ ); }
202
[09687aa]203// public
[6c5d92f]204void ?{}( ifstream & is ) { is.file$ = 0p; }
[7ce2483]205void ?{}( ifstream & is, const char name[], const char mode[] ) { open( is, name, mode ); }
206void ?{}( ifstream & is, const char name[] ) { open( is, name, "r" ); }
207void ^?{}( ifstream & is ) { close( is ); }
[4cae032]208
[6c5d92f]209void nlOn( ifstream & os ) { os.nlOnOff$ = true; }
210void nlOff( ifstream & os ) { os.nlOnOff$ = false; }
211bool getANL( ifstream & os ) { return os.nlOnOff$; }
[0efb269]212
[7ce2483]213bool fail( ifstream & is ) { return is.file$ == 0p || ferror( (FILE *)(is.file$) ); }
214void clear( ifstream & is ) { clearerr( (FILE *)(is.file$) ); }
[00e9be9]215
[e474cf09]216void ends( ifstream & is ) {
[7ce2483]217        if ( is.acquired$ ) { is.acquired$ = false; unlock( is ); }
[e474cf09]218} // ends
219
[7ce2483]220bool eof( ifstream & is ) { return feof( (FILE *)(is.file$) ); }
[6ba0659]221
[e3fea42]222void open( ifstream & is, const char name[], const char mode[] ) {
[8a25be9]223        FILE * file = fopen( name, mode );
[d1a9ff5]224        if ( file == 0p ) {
[8d321f9]225                throw (Open_Failure){ is };
226                // abort | IO_MSG "open input file \"" | name | "\"" | nl | strerror( errno );
[93c2e0a]227        } // if
[3bf3b6b]228        (is){ file };                                                                           // initialize
[90c3b1c]229} // open
[6ba0659]230
[7ce2483]231void open( ifstream & is, const char name[] ) { open( is, name, "r" ); }
[8da74119]232
[7ce2483]233void close( ifstream & is ) with( is ) {
[3bf3b6b]234  if ( (FILE *)(file$) == 0p ) return;
235  if ( (FILE *)(file$) == (FILE *)stdin ) return;
[90c3b1c]236
[3bf3b6b]237        if ( fclose( (FILE *)(file$) ) == EOF ) {
[ba0d2ea]238                throw (Close_Failure){ is };
239                // abort | IO_MSG "close input" | nl | strerror( errno );
[356189a]240        } // if
[3bf3b6b]241        file$ = 0p;
[90c3b1c]242} // close
243
[00e9be9]244ifstream & read( ifstream & is, char data[], size_t size ) {
[6ba0659]245        if ( fail( is ) ) {
[ba0d2ea]246                throw (Read_Failure){ is };
247                // abort | IO_MSG "attempt read I/O on failed stream";
[6ba0659]248        } // if
249
[6c5d92f]250        if ( fread( data, size, 1, (FILE *)(is.file$) ) == 0 ) {
[ba0d2ea]251                throw (Read_Failure){ is };
252                // abort | IO_MSG "read" | nl | strerror( errno );
[6ba0659]253        } // if
[86bd7c1f]254        return is;
[6ba0659]255} // read
[356189a]256
[09687aa]257ifstream &ungetc( ifstream & is, char c ) {
[6ba0659]258        if ( fail( is ) ) {
[ff2a33e]259                abort | IO_MSG "attempt ungetc I/O on failed stream";
[6ba0659]260        } // if
[51b7345]261
[6c5d92f]262        if ( ungetc( c, (FILE *)(is.file$) ) == EOF ) {
[ff2a33e]263                abort | IO_MSG "ungetc" | nl | strerror( errno );
[6ba0659]264        } // if
265        return is;
266} // ungetc
[51b7345]267
[09687aa]268int fmt( ifstream & is, const char format[], ... ) {
[5d125e4]269        va_list args;
[51b7345]270
[829c907]271        va_start( args, format );
[6c5d92f]272        int len = vfscanf( (FILE *)(is.file$), format, args );
[90c3b1c]273        if ( len == EOF ) {
[6c5d92f]274                if ( ferror( (FILE *)(is.file$) ) ) {
[ff2a33e]275                        abort | IO_MSG "invalid read";
[90c3b1c]276                } // if
277        } // if
[5d125e4]278        va_end( args );
[90c3b1c]279        return len;
[829c907]280} // fmt
[51b7345]281
[7ce2483]282void acquire( ifstream & is ) with( is ) {
283        lock( is );                                                                                     // may increase recursive lock
[3bf3b6b]284        if ( ! acquired$ ) acquired$ = true;                            // not locked ?
[7ce2483]285        else unlock( is );                                                                      // unwind recursive lock at start
[e474cf09]286} // acquire
287
[7ce2483]288void ?{}( isacquire & acq, ifstream & is ) { &acq.is = &is; lock( is ); }
289void ^?{}( isacquire & acq ) { unlock( acq.is ); }
[e474cf09]290
[fd8f88f]291static ifstream sinFile = { (FILE *)stdin };
[a87d40b]292ifstream & sin = sinFile, & stdin = sinFile;
[86bd7c1f]293
[91e52be]294
[8d321f9]295// *********************************** exceptions ***********************************
[91e52be]296
297
[ba0d2ea]298static vtable(Open_Failure) Open_Failure_vt;
[a5a6a1a8]299
300// exception I/O constructors
[3bf3b6b]301void ?{}( Open_Failure & ex, ofstream & ostream ) with(ex) {
302        virtual_table = &Open_Failure_vt;
303        ostream = &ostream;
304        tag = 1;
[a5a6a1a8]305} // ?{}
306
[3bf3b6b]307void ?{}( Open_Failure & ex, ifstream & istream ) with(ex) {
308        virtual_table = &Open_Failure_vt;
309        istream = &istream;
310        tag = 0;
[a5a6a1a8]311} // ?{}
312
313
[ba0d2ea]314static vtable(Close_Failure) Close_Failure_vt;
315
316// exception I/O constructors
[3bf3b6b]317void ?{}( Close_Failure & ex, ofstream & ostream ) with(ex) {
318        virtual_table = &Close_Failure_vt;
319        ostream = &ostream;
320        tag = 1;
[ba0d2ea]321} // ?{}
322
[3bf3b6b]323void ?{}( Close_Failure & ex, ifstream & istream ) with(ex) {
324        virtual_table = &Close_Failure_vt;
325        istream = &istream;
326        tag = 0;
[ba0d2ea]327} // ?{}
328
329
330static vtable(Write_Failure) Write_Failure_vt;
331
332// exception I/O constructors
[3bf3b6b]333void ?{}( Write_Failure & ex, ofstream & ostream ) with(ex) {
334        virtual_table = &Write_Failure_vt;
335        ostream = &ostream;
336        tag = 1;
[ba0d2ea]337} // ?{}
338
[3bf3b6b]339void ?{}( Write_Failure & ex, ifstream & istream ) with(ex) {
340        virtual_table = &Write_Failure_vt;
341        istream = &istream;
342        tag = 0;
[ba0d2ea]343} // ?{}
344
345
346static vtable(Read_Failure) Read_Failure_vt;
347
348// exception I/O constructors
[3bf3b6b]349void ?{}( Read_Failure & ex, ofstream & ostream ) with(ex) {
350        virtual_table = &Read_Failure_vt;
351        ostream = &ostream;
352        tag = 1;
[ba0d2ea]353} // ?{}
354
[3bf3b6b]355void ?{}( Read_Failure & ex, ifstream & istream ) with(ex) {
356        virtual_table = &Read_Failure_vt;
357        istream = &istream;
358        tag = 0;
[ba0d2ea]359} // ?{}
360
361// void throwOpen_Failure( ofstream & ostream ) {
362//      Open_Failure exc = { ostream };
363// }
364
365// void throwOpen_Failure( ifstream & istream ) {
366//      Open_Failure exc = { istream };
367// }
[91e52be]368
[86bd7c1f]369// Local Variables: //
370// tab-width: 4 //
371// End: //
Note: See TracBrowser for help on using the repository browser.