Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/fstream.cfa

    r7ce2483 r7e7a076  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Oct  1 08:10:21 2021
    13 // Update Count     : 473
     12// Last Modified On : Thu Jul 29 22:34:10 2021
     13// Update Count     : 454
    1414//
    1515
     
    2828#define IO_MSG "I/O error: "
    2929
    30 // private
    31 void ?{}( 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;
     30void ?{}( 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;
    3938        sepSetCur$( os, sepGet( os ) );
    4039        sepSet( os, " " );
     
    4241} // ?{}
    4342
    44 inline bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
    45 inline void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
    46 inline void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
    47 inline const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
    48 inline void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
    49 inline bool getNL$( ofstream & os ) { return os.sawNL$; }
    50 inline void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
    51 inline bool getANL$( ofstream & os ) { return os.nlOnOff$; }
    52 inline bool getPrt$( ofstream & os ) { return os.prt$; }
    53 inline void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
    54 
    55 inline void lock( ofstream & os ) with( os ) {  lock( os.lock$ ); }
    56 inline void unlock( ofstream & os ) { unlock( os.lock$ ); }
     43// private
     44bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
     45void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
     46void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
     47const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
     48void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
     49bool getNL$( ofstream & os ) { return os.sawNL$; }
     50void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
     51bool getANL$( ofstream & os ) { return os.nlOnOff$; }
     52bool getPrt$( ofstream & os ) { return os.prt$; }
     53void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
    5754
    5855// public
    5956void ?{}( ofstream & os ) { os.file$ = 0p; }
    60 void ?{}( ofstream & os, const char name[], const char mode[] ) { open( os, name, mode ); }
    61 void ?{}( ofstream & os, const char name[] ) { open( os, name, "w" ); }
    62 void ^?{}( ofstream & os ) { close( os ); }
     57
     58void ?{}( ofstream & os, const char name[], const char mode[] ) {
     59        open( os, name, mode );
     60} // ?{}
     61
     62void ?{}( ofstream & os, const char name[] ) {
     63        open( os, name, "w" );
     64} // ?{}
     65
     66void ^?{}( ofstream & os ) {
     67        close( os );
     68} // ^?{}
    6369
    6470void sepOn( ofstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
     
    101107        if ( &os == &exit ) exit( EXIT_FAILURE );
    102108        if ( &os == &abort ) abort();
    103         if ( os.acquired$ ) { os.acquired$ = false; unlock( os ); }
     109        if ( os.acquired$ ) { os.acquired$ = false; release( os ); }
    104110} // ends
    105111
    106 bool fail( ofstream & os ) { return os.file$ == 0 || ferror( (FILE *)(os.file$) ); }
    107 void clear( ofstream & os ) { clearerr( (FILE *)(os.file$) ); }
    108 int flush( ofstream & os ) { return fflush( (FILE *)(os.file$) ); }
     112bool fail( ofstream & os ) {
     113        return os.file$ == 0 || ferror( (FILE *)(os.file$) );
     114} // fail
     115
     116void clear( ofstream & os ) {
     117        clearerr( (FILE *)(os.file$) );
     118} // clear
     119
     120int flush( ofstream & os ) {
     121        return fflush( (FILE *)(os.file$) );
     122} // flush
    109123
    110124void open( ofstream & os, const char name[], const char mode[] ) {
    111125        FILE * file = fopen( name, mode );
     126        // #ifdef __CFA_DEBUG__
    112127        if ( file == 0p ) {
    113128                throw (Open_Failure){ os };
    114129                // abort | IO_MSG "open output file \"" | name | "\"" | nl | strerror( errno );
    115130        } // if
    116         (os){ file };                                                                           // initialize
     131        // #endif // __CFA_DEBUG__
     132        (os){ file };
    117133} // open
    118134
    119 void open( ofstream & os, const char name[] ) { open( os, name, "w" ); }
    120 
    121 void 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 ) {
     135void open( ofstream & os, const char name[] ) {
     136        open( os, name, "w" );
     137} // open
     138
     139void 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 ) {
    126144                throw (Close_Failure){ os };
    127145                // abort | IO_MSG "close output" | nl | strerror( errno );
    128146        } // if
    129         file$ = 0p;                                                                                     // safety after close
     147        os.file$ = 0p;
    130148} // close
    131149
     
    159177} // fmt
    160178
    161 void 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
     179inline void acquire( ofstream & os ) {
     180        lock( os.lock$ );
     181        if ( ! os.acquired$ ) os.acquired$ = true;
     182        else unlock( os.lock$ );
    165183} // acquire
    166184
    167 void ?{}( osacquire & acq, ofstream & os ) { &acq.os = &os; lock( os ); }
    168 void ^?{}( osacquire & acq ) { unlock( acq.os ); }
     185inline void release( ofstream & os ) {
     186        unlock( os.lock$ );
     187} // release
     188
     189inline void lock( ofstream & os ) { acquire( os ); }
     190inline void unlock( ofstream & os ) { release( os ); }
     191
     192void ?{}( osacquire & acq, ofstream & os ) { &acq.os = &os; lock( os.lock$ ); }
     193void ^?{}( osacquire & acq ) { release( acq.os ); }
    169194
    170195static ofstream soutFile = { (FILE *)stdout };
     
    185210        flush( os );
    186211        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
    187217} // nl
    188218
     
    192222
    193223// private
    194 void ?{}( ifstream & is, void * file ) with( is ) {
    195         file$ = file;
    196         nlOnOff$ = false;
    197         acquired$ = false;
    198 } // ?{}
    199 
    200 inline void lock( ifstream & os ) with( os ) { lock( os.lock$ ); }
    201 inline void unlock( ifstream & os ) { unlock( os.lock$ ); }
     224void ?{}( ifstream & is, void * file ) {
     225        is.file$ = file;
     226        is.nlOnOff$ = false;
     227        is.acquired$ = false;
     228} // ?{}
    202229
    203230// public
    204231void ?{}( ifstream & is ) { is.file$ = 0p; }
    205 void ?{}( ifstream & is, const char name[], const char mode[] ) { open( is, name, mode ); }
    206 void ?{}( ifstream & is, const char name[] ) { open( is, name, "r" ); }
    207 void ^?{}( ifstream & is ) { close( is ); }
     232
     233void ?{}( ifstream & is, const char name[], const char mode[] ) {
     234        open( is, name, mode );
     235} // ?{}
     236
     237void ?{}( ifstream & is, const char name[] ) {
     238        open( is, name, "r" );
     239} // ?{}
     240
     241void ^?{}( ifstream & is ) {
     242        close( is );
     243} // ^?{}
    208244
    209245void nlOn( ifstream & os ) { os.nlOnOff$ = true; }
     
    211247bool getANL( ifstream & os ) { return os.nlOnOff$; }
    212248
    213 bool fail( ifstream & is ) { return is.file$ == 0p || ferror( (FILE *)(is.file$) ); }
    214 void clear( ifstream & is ) { clearerr( (FILE *)(is.file$) ); }
     249bool fail( ifstream & is ) {
     250        return is.file$ == 0p || ferror( (FILE *)(is.file$) );
     251} // fail
     252
     253void clear( ifstream & is ) {
     254        clearerr( (FILE *)(is.file$) );
     255} // clear
    215256
    216257void ends( ifstream & is ) {
    217         if ( is.acquired$ ) { is.acquired$ = false; unlock( is ); }
     258        if ( is.acquired$ ) { is.acquired$ = false; release( is ); }
    218259} // ends
    219260
    220 bool eof( ifstream & is ) { return feof( (FILE *)(is.file$) ); }
     261bool eof( ifstream & is ) {
     262        return feof( (FILE *)(is.file$) );
     263} // eof
    221264
    222265void open( ifstream & is, const char name[], const char mode[] ) {
    223266        FILE * file = fopen( name, mode );
     267        // #ifdef __CFA_DEBUG__
    224268        if ( file == 0p ) {
    225269                throw (Open_Failure){ is };
    226270                // abort | IO_MSG "open input file \"" | name | "\"" | nl | strerror( errno );
    227271        } // if
    228         (is){ file };                                                                           // initialize
     272        // #endif // __CFA_DEBUG__
     273        is.file$ = file;
    229274} // open
    230275
    231 void open( ifstream & is, const char name[] ) { open( is, name, "r" ); }
    232 
    233 void 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 ) {
     276void open( ifstream & is, const char name[] ) {
     277        open( is, name, "r" );
     278} // open
     279
     280void 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 ) {
    238285                throw (Close_Failure){ is };
    239286                // abort | IO_MSG "close input" | nl | strerror( errno );
    240287        } // if
    241         file$ = 0p;
     288        is.file$ = 0p;
    242289} // close
    243290
     
    280327} // fmt
    281328
    282 void 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
     329inline void acquire( ifstream & is ) {
     330        lock( is.lock$ );
     331        if ( ! is.acquired$ ) is.acquired$ = true;
     332        else unlock( is.lock$ );
    286333} // acquire
    287334
    288 void ?{}( isacquire & acq, ifstream & is ) { &acq.is = &is; lock( is ); }
    289 void ^?{}( isacquire & acq ) { unlock( acq.is ); }
     335inline void release( ifstream & is ) {
     336        unlock( is.lock$ );
     337} // release
     338
     339void ?{}( isacquire & acq, ifstream & is ) { &acq.is = &is; lock( is.lock$ ); }
     340void ^?{}( isacquire & acq ) { release( acq.is ); }
    290341
    291342static ifstream sinFile = { (FILE *)stdin };
     
    299350
    300351// exception I/O constructors
    301 void ?{}( Open_Failure & ex, ofstream & ostream ) with(ex) {
    302         virtual_table = &Open_Failure_vt;
    303         ostream = &ostream;
    304         tag = 1;
    305 } // ?{}
    306 
    307 void ?{}( Open_Failure & ex, ifstream & istream ) with(ex) {
    308         virtual_table = &Open_Failure_vt;
    309         istream = &istream;
    310         tag = 0;
     352void ?{}( Open_Failure & this, ofstream & ostream ) {
     353        this.virtual_table = &Open_Failure_vt;
     354        this.ostream = &ostream;
     355        this.tag = 1;
     356} // ?{}
     357
     358void ?{}( Open_Failure & this, ifstream & istream ) {
     359        this.virtual_table = &Open_Failure_vt;
     360        this.istream = &istream;
     361        this.tag = 0;
    311362} // ?{}
    312363
     
    315366
    316367// exception I/O constructors
    317 void ?{}( Close_Failure & ex, ofstream & ostream ) with(ex) {
    318         virtual_table = &Close_Failure_vt;
    319         ostream = &ostream;
    320         tag = 1;
    321 } // ?{}
    322 
    323 void ?{}( Close_Failure & ex, ifstream & istream ) with(ex) {
    324         virtual_table = &Close_Failure_vt;
    325         istream = &istream;
    326         tag = 0;
     368void ?{}( Close_Failure & this, ofstream & ostream ) {
     369        this.virtual_table = &Close_Failure_vt;
     370        this.ostream = &ostream;
     371        this.tag = 1;
     372} // ?{}
     373
     374void ?{}( Close_Failure & this, ifstream & istream ) {
     375        this.virtual_table = &Close_Failure_vt;
     376        this.istream = &istream;
     377        this.tag = 0;
    327378} // ?{}
    328379
     
    331382
    332383// exception I/O constructors
    333 void ?{}( Write_Failure & ex, ofstream & ostream ) with(ex) {
    334         virtual_table = &Write_Failure_vt;
    335         ostream = &ostream;
    336         tag = 1;
    337 } // ?{}
    338 
    339 void ?{}( Write_Failure & ex, ifstream & istream ) with(ex) {
    340         virtual_table = &Write_Failure_vt;
    341         istream = &istream;
    342         tag = 0;
     384void ?{}( Write_Failure & this, ofstream & ostream ) {
     385        this.virtual_table = &Write_Failure_vt;
     386        this.ostream = &ostream;
     387        this.tag = 1;
     388} // ?{}
     389
     390void ?{}( Write_Failure & this, ifstream & istream ) {
     391        this.virtual_table = &Write_Failure_vt;
     392        this.istream = &istream;
     393        this.tag = 0;
    343394} // ?{}
    344395
     
    347398
    348399// exception I/O constructors
    349 void ?{}( Read_Failure & ex, ofstream & ostream ) with(ex) {
    350         virtual_table = &Read_Failure_vt;
    351         ostream = &ostream;
    352         tag = 1;
    353 } // ?{}
    354 
    355 void ?{}( Read_Failure & ex, ifstream & istream ) with(ex) {
    356         virtual_table = &Read_Failure_vt;
    357         istream = &istream;
    358         tag = 0;
     400void ?{}( Read_Failure & this, ofstream & ostream ) {
     401        this.virtual_table = &Read_Failure_vt;
     402        this.ostream = &ostream;
     403        this.tag = 1;
     404} // ?{}
     405
     406void ?{}( Read_Failure & this, ifstream & istream ) {
     407        this.virtual_table = &Read_Failure_vt;
     408        this.istream = &istream;
     409        this.tag = 0;
    359410} // ?{}
    360411
Note: See TracChangeset for help on using the changeset viewer.