Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/fstream.cfa

    r7e7a076 r7ce2483  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jul 29 22:34:10 2021
    13 // Update Count     : 454
     12// Last Modified On : Fri Oct  1 08:10:21 2021
     13// Update Count     : 473
    1414//
    1515
     
    2828#define IO_MSG "I/O error: "
    2929
    30 void ?{}( ofstream & os, void * file ) {
    31         os.file$ = file;
    32         os.sepDefault$ = true;
    33         os.sepOnOff$ = false;
    34         os.nlOnOff$ = true;
    35         os.prt$ = false;
    36         os.sawNL$ = false;
    37         os.acquired$ = false;
     30// private
     31void ?{}( ofstream & os, void * file ) with( os ) {
     32        file$ = file;
     33        sepDefault$ = true;
     34        sepOnOff$ = false;
     35        nlOnOff$ = true;
     36        prt$ = false;
     37        sawNL$ = false;
     38        acquired$ = false;
    3839        sepSetCur$( os, sepGet( os ) );
    3940        sepSet( os, " " );
     
    4142} // ?{}
    4243
    43 // private
    44 bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
    45 void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
    46 void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
    47 const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
    48 void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
    49 bool getNL$( ofstream & os ) { return os.sawNL$; }
    50 void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
    51 bool getANL$( ofstream & os ) { return os.nlOnOff$; }
    52 bool getPrt$( ofstream & os ) { return os.prt$; }
    53 void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
     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$ ); }
    5457
    5558// public
    5659void ?{}( ofstream & os ) { os.file$ = 0p; }
    57 
    58 void ?{}( ofstream & os, const char name[], const char mode[] ) {
    59         open( os, name, mode );
    60 } // ?{}
    61 
    62 void ?{}( ofstream & os, const char name[] ) {
    63         open( os, name, "w" );
    64 } // ?{}
    65 
    66 void ^?{}( ofstream & os ) {
    67         close( os );
    68 } // ^?{}
     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 ); }
    6963
    7064void sepOn( ofstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
     
    107101        if ( &os == &exit ) exit( EXIT_FAILURE );
    108102        if ( &os == &abort ) abort();
    109         if ( os.acquired$ ) { os.acquired$ = false; release( os ); }
     103        if ( os.acquired$ ) { os.acquired$ = false; unlock( os ); }
    110104} // ends
    111105
    112 bool fail( ofstream & os ) {
    113         return os.file$ == 0 || ferror( (FILE *)(os.file$) );
    114 } // fail
    115 
    116 void clear( ofstream & os ) {
    117         clearerr( (FILE *)(os.file$) );
    118 } // clear
    119 
    120 int flush( ofstream & os ) {
    121         return fflush( (FILE *)(os.file$) );
    122 } // flush
     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$) ); }
    123109
    124110void open( ofstream & os, const char name[], const char mode[] ) {
    125111        FILE * file = fopen( name, mode );
    126         // #ifdef __CFA_DEBUG__
    127112        if ( file == 0p ) {
    128113                throw (Open_Failure){ os };
    129114                // abort | IO_MSG "open output file \"" | name | "\"" | nl | strerror( errno );
    130115        } // if
    131         // #endif // __CFA_DEBUG__
    132         (os){ file };
     116        (os){ file };                                                                           // initialize
    133117} // open
    134118
    135 void open( ofstream & os, const char name[] ) {
    136         open( os, name, "w" );
    137 } // open
    138 
    139 void close( ofstream & os ) {
    140   if ( (FILE *)(os.file$) == 0p ) return;
    141   if ( (FILE *)(os.file$) == (FILE *)stdout || (FILE *)(os.file$) == (FILE *)stderr ) return;
    142 
    143         if ( fclose( (FILE *)(os.file$) ) == EOF ) {
     119void open( ofstream & os, const char name[] ) { open( os, name, "w" ); }
     120
     121void close( ofstream & os ) with( os ) {
     122  if ( (FILE *)(file$) == 0p ) return;
     123  if ( (FILE *)(file$) == (FILE *)stdout || (FILE *)(file$) == (FILE *)stderr ) return;
     124
     125        if ( fclose( (FILE *)(file$) ) == EOF ) {
    144126                throw (Close_Failure){ os };
    145127                // abort | IO_MSG "close output" | nl | strerror( errno );
    146128        } // if
    147         os.file$ = 0p;
     129        file$ = 0p;                                                                                     // safety after close
    148130} // close
    149131
     
    177159} // fmt
    178160
    179 inline void acquire( ofstream & os ) {
    180         lock( os.lock$ );
    181         if ( ! os.acquired$ ) os.acquired$ = true;
    182         else unlock( os.lock$ );
     161void acquire( ofstream & os ) with( os ) {
     162        lock( os );                                                                                     // may increase recursive lock
     163        if ( ! acquired$ ) acquired$ = true;                            // not locked ?
     164        else unlock( os );                                                                      // unwind recursive lock at start
    183165} // acquire
    184166
    185 inline void release( ofstream & os ) {
    186         unlock( os.lock$ );
    187 } // release
    188 
    189 inline void lock( ofstream & os ) { acquire( os ); }
    190 inline void unlock( ofstream & os ) { release( os ); }
    191 
    192 void ?{}( osacquire & acq, ofstream & os ) { &acq.os = &os; lock( os.lock$ ); }
    193 void ^?{}( osacquire & acq ) { release( acq.os ); }
     167void ?{}( osacquire & acq, ofstream & os ) { &acq.os = &os; lock( os ); }
     168void ^?{}( osacquire & acq ) { unlock( acq.os ); }
    194169
    195170static ofstream soutFile = { (FILE *)stdout };
     
    210185        flush( os );
    211186        return os;
    212         // (ofstream &)(os | '\n');
    213         // setPrt$( os, false );                                                        // turn off
    214         // setNL$( os, true );
    215         // flush( os );
    216         // return sepOff( os );                                                 // prepare for next line
    217187} // nl
    218188
     
    222192
    223193// private
    224 void ?{}( ifstream & is, void * file ) {
    225         is.file$ = file;
    226         is.nlOnOff$ = false;
    227         is.acquired$ = false;
    228 } // ?{}
     194void ?{}( ifstream & is, void * file ) with( is ) {
     195        file$ = file;
     196        nlOnOff$ = false;
     197        acquired$ = false;
     198} // ?{}
     199
     200inline void lock( ifstream & os ) with( os ) { lock( os.lock$ ); }
     201inline void unlock( ifstream & os ) { unlock( os.lock$ ); }
    229202
    230203// public
    231204void ?{}( ifstream & is ) { is.file$ = 0p; }
    232 
    233 void ?{}( ifstream & is, const char name[], const char mode[] ) {
    234         open( is, name, mode );
    235 } // ?{}
    236 
    237 void ?{}( ifstream & is, const char name[] ) {
    238         open( is, name, "r" );
    239 } // ?{}
    240 
    241 void ^?{}( ifstream & is ) {
    242         close( is );
    243 } // ^?{}
     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 ); }
    244208
    245209void nlOn( ifstream & os ) { os.nlOnOff$ = true; }
     
    247211bool getANL( ifstream & os ) { return os.nlOnOff$; }
    248212
    249 bool fail( ifstream & is ) {
    250         return is.file$ == 0p || ferror( (FILE *)(is.file$) );
    251 } // fail
    252 
    253 void clear( ifstream & is ) {
    254         clearerr( (FILE *)(is.file$) );
    255 } // clear
     213bool fail( ifstream & is ) { return is.file$ == 0p || ferror( (FILE *)(is.file$) ); }
     214void clear( ifstream & is ) { clearerr( (FILE *)(is.file$) ); }
    256215
    257216void ends( ifstream & is ) {
    258         if ( is.acquired$ ) { is.acquired$ = false; release( is ); }
     217        if ( is.acquired$ ) { is.acquired$ = false; unlock( is ); }
    259218} // ends
    260219
    261 bool eof( ifstream & is ) {
    262         return feof( (FILE *)(is.file$) );
    263 } // eof
     220bool eof( ifstream & is ) { return feof( (FILE *)(is.file$) ); }
    264221
    265222void open( ifstream & is, const char name[], const char mode[] ) {
    266223        FILE * file = fopen( name, mode );
    267         // #ifdef __CFA_DEBUG__
    268224        if ( file == 0p ) {
    269225                throw (Open_Failure){ is };
    270226                // abort | IO_MSG "open input file \"" | name | "\"" | nl | strerror( errno );
    271227        } // if
    272         // #endif // __CFA_DEBUG__
    273         is.file$ = file;
     228        (is){ file };                                                                           // initialize
    274229} // open
    275230
    276 void open( ifstream & is, const char name[] ) {
    277         open( is, name, "r" );
    278 } // open
    279 
    280 void close( ifstream & is ) {
    281   if ( (FILE *)(is.file$) == 0p ) return;
    282   if ( (FILE *)(is.file$) == (FILE *)stdin ) return;
    283 
    284         if ( fclose( (FILE *)(is.file$) ) == EOF ) {
     231void open( ifstream & is, const char name[] ) { open( is, name, "r" ); }
     232
     233void close( ifstream & is ) with( is ) {
     234  if ( (FILE *)(file$) == 0p ) return;
     235  if ( (FILE *)(file$) == (FILE *)stdin ) return;
     236
     237        if ( fclose( (FILE *)(file$) ) == EOF ) {
    285238                throw (Close_Failure){ is };
    286239                // abort | IO_MSG "close input" | nl | strerror( errno );
    287240        } // if
    288         is.file$ = 0p;
     241        file$ = 0p;
    289242} // close
    290243
     
    327280} // fmt
    328281
    329 inline void acquire( ifstream & is ) {
    330         lock( is.lock$ );
    331         if ( ! is.acquired$ ) is.acquired$ = true;
    332         else unlock( is.lock$ );
     282void acquire( ifstream & is ) with( is ) {
     283        lock( is );                                                                                     // may increase recursive lock
     284        if ( ! acquired$ ) acquired$ = true;                            // not locked ?
     285        else unlock( is );                                                                      // unwind recursive lock at start
    333286} // acquire
    334287
    335 inline void release( ifstream & is ) {
    336         unlock( is.lock$ );
    337 } // release
    338 
    339 void ?{}( isacquire & acq, ifstream & is ) { &acq.is = &is; lock( is.lock$ ); }
    340 void ^?{}( isacquire & acq ) { release( acq.is ); }
     288void ?{}( isacquire & acq, ifstream & is ) { &acq.is = &is; lock( is ); }
     289void ^?{}( isacquire & acq ) { unlock( acq.is ); }
    341290
    342291static ifstream sinFile = { (FILE *)stdin };
     
    350299
    351300// exception I/O constructors
    352 void ?{}( Open_Failure & this, ofstream & ostream ) {
    353         this.virtual_table = &Open_Failure_vt;
    354         this.ostream = &ostream;
    355         this.tag = 1;
    356 } // ?{}
    357 
    358 void ?{}( Open_Failure & this, ifstream & istream ) {
    359         this.virtual_table = &Open_Failure_vt;
    360         this.istream = &istream;
    361         this.tag = 0;
     301void ?{}( Open_Failure & ex, ofstream & ostream ) with(ex) {
     302        virtual_table = &Open_Failure_vt;
     303        ostream = &ostream;
     304        tag = 1;
     305} // ?{}
     306
     307void ?{}( Open_Failure & ex, ifstream & istream ) with(ex) {
     308        virtual_table = &Open_Failure_vt;
     309        istream = &istream;
     310        tag = 0;
    362311} // ?{}
    363312
     
    366315
    367316// exception I/O constructors
    368 void ?{}( Close_Failure & this, ofstream & ostream ) {
    369         this.virtual_table = &Close_Failure_vt;
    370         this.ostream = &ostream;
    371         this.tag = 1;
    372 } // ?{}
    373 
    374 void ?{}( Close_Failure & this, ifstream & istream ) {
    375         this.virtual_table = &Close_Failure_vt;
    376         this.istream = &istream;
    377         this.tag = 0;
     317void ?{}( Close_Failure & ex, ofstream & ostream ) with(ex) {
     318        virtual_table = &Close_Failure_vt;
     319        ostream = &ostream;
     320        tag = 1;
     321} // ?{}
     322
     323void ?{}( Close_Failure & ex, ifstream & istream ) with(ex) {
     324        virtual_table = &Close_Failure_vt;
     325        istream = &istream;
     326        tag = 0;
    378327} // ?{}
    379328
     
    382331
    383332// exception I/O constructors
    384 void ?{}( Write_Failure & this, ofstream & ostream ) {
    385         this.virtual_table = &Write_Failure_vt;
    386         this.ostream = &ostream;
    387         this.tag = 1;
    388 } // ?{}
    389 
    390 void ?{}( Write_Failure & this, ifstream & istream ) {
    391         this.virtual_table = &Write_Failure_vt;
    392         this.istream = &istream;
    393         this.tag = 0;
     333void ?{}( Write_Failure & ex, ofstream & ostream ) with(ex) {
     334        virtual_table = &Write_Failure_vt;
     335        ostream = &ostream;
     336        tag = 1;
     337} // ?{}
     338
     339void ?{}( Write_Failure & ex, ifstream & istream ) with(ex) {
     340        virtual_table = &Write_Failure_vt;
     341        istream = &istream;
     342        tag = 0;
    394343} // ?{}
    395344
     
    398347
    399348// exception I/O constructors
    400 void ?{}( Read_Failure & this, ofstream & ostream ) {
    401         this.virtual_table = &Read_Failure_vt;
    402         this.ostream = &ostream;
    403         this.tag = 1;
    404 } // ?{}
    405 
    406 void ?{}( Read_Failure & this, ifstream & istream ) {
    407         this.virtual_table = &Read_Failure_vt;
    408         this.istream = &istream;
    409         this.tag = 0;
     349void ?{}( Read_Failure & ex, ofstream & ostream ) with(ex) {
     350        virtual_table = &Read_Failure_vt;
     351        ostream = &ostream;
     352        tag = 1;
     353} // ?{}
     354
     355void ?{}( Read_Failure & ex, ifstream & istream ) with(ex) {
     356        virtual_table = &Read_Failure_vt;
     357        istream = &istream;
     358        tag = 0;
    410359} // ?{}
    411360
Note: See TracChangeset for help on using the changeset viewer.