Changeset a2e4b0c for libcfa/src


Ignore:
Timestamp:
Oct 28, 2021, 11:08:27 AM (3 years ago)
Author:
caparsons <caparson@…>
Branches:
ADT, ast-experimental, enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum
Children:
441d11c
Parents:
a51a02d (diff), 15885de9 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:
libcfa/src
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/fstream.cfa

    ra51a02d ra2e4b0c  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Sep 21 21:51:38 2021
    13 // Update Count     : 460
     12// Last Modified On : Sun Oct 10 11:23:05 2021
     13// Update Count     : 512
    1414//
    1515
    … …  
    2828#define IO_MSG "I/O error: "
    2929
    30 void ?{}( ofstream & os, void * file ) with(os) {
     30// private
     31void ?{}( ofstream & os, void * file ) with( os ) {
    3132        file$ = file;
    3233        sepDefault$ = true;
    … …  
    3536        prt$ = false;
    3637        sawNL$ = false;
    37         acquired$ = false;
    3838        sepSetCur$( os, sepGet( os ) );
    3939        sepSet( os, " " );
    … …  
    4141} // ?{}
    4242
    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; }
     43inline bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
     44inline void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
     45inline void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
     46inline const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
     47inline void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
     48inline bool getNL$( ofstream & os ) { return os.sawNL$; }
     49inline void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
     50inline bool getANL$( ofstream & os ) { return os.nlOnOff$; }
     51inline bool getPrt$( ofstream & os ) { return os.prt$; }
     52inline void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
     53
     54inline void lock( ofstream & os ) with( os ) {  lock( os.lock$ ); }
     55inline void unlock( ofstream & os ) { unlock( os.lock$ ); }
    5456
    5557// public
    5658void ?{}( 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 } // ^?{}
     59void ?{}( ofstream & os, const char name[], const char mode[] ) { open( os, name, mode ); }
     60void ?{}( ofstream & os, const char name[] ) { open( os, name, "w" ); }
     61void ^?{}( ofstream & os ) { close( os ); }
    6962
    7063void sepOn( ofstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
    … …  
    107100        if ( &os == &exit ) exit( EXIT_FAILURE );
    108101        if ( &os == &abort ) abort();
    109         if ( os.acquired$ ) { os.acquired$ = false; release( os ); }
    110102} // ends
    111103
    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
     104bool fail( ofstream & os ) { return os.file$ == 0 || ferror( (FILE *)(os.file$) ); }
     105void clear( ofstream & os ) { clearerr( (FILE *)(os.file$) ); }
     106int flush( ofstream & os ) { return fflush( (FILE *)(os.file$) ); }
    123107
    124108void open( ofstream & os, const char name[], const char mode[] ) {
    125         FILE * file = fopen( name, mode );
     109        FILE * file;
     110    for ( cnt; 10 ) {
     111                errno = 0;
     112                file = fopen( name, mode );
     113          if ( file != 0p || errno != EINTR ) break;            // timer interrupt ?
     114          if ( cnt == 9 ) abort( "ofstream open EINTR spinning exceeded" );
     115    } // for
    126116        if ( file == 0p ) {
    127117                throw (Open_Failure){ os };
    … …  
    131121} // open
    132122
    133 void open( ofstream & os, const char name[] ) {
    134         open( os, name, "w" );
    135 } // open
    136 
    137 void close( ofstream & os ) with(os) {
     123void open( ofstream & os, const char name[] ) { open( os, name, "w" ); }
     124
     125void close( ofstream & os ) with( os ) {
    138126  if ( (FILE *)(file$) == 0p ) return;
    139127  if ( (FILE *)(file$) == (FILE *)stdout || (FILE *)(file$) == (FILE *)stderr ) return;
    140128
    141         if ( fclose( (FILE *)(file$) ) == EOF ) {
     129        int ret;
     130    for ( cnt; 10 ) {
     131                errno = 0;
     132                ret = fclose( (FILE *)(file$) );
     133          if ( ret != EOF || errno != EINTR ) break;            // timer interrupt ?
     134          if ( cnt == 9 ) abort( "ofstream open EINTR spinning exceeded" );
     135    } // for
     136        if ( ret == EOF ) {
    142137                throw (Close_Failure){ os };
    143138                // abort | IO_MSG "close output" | nl | strerror( errno );
    144139        } // if
    145         file$ = 0p;
     140        file$ = 0p;                                                                                     // safety after close
    146141} // close
    147142
    … …  
    162157        va_list args;
    163158        va_start( args, format );
    164         int len = vfprintf( (FILE *)(os.file$), format, args );
     159               
     160        int len;
     161    for ( cnt; 10 ) {
     162                errno = 0;
     163                len = vfprintf( (FILE *)(os.file$), format, args );
     164          if ( len != EOF || errno != EINTR ) break;            // timer interrupt ?
     165          if ( cnt == 9 ) abort( "ofstream fmt EINTR spinning exceeded" );
     166    } // for
    165167        if ( len == EOF ) {
    166168                if ( ferror( (FILE *)(os.file$) ) ) {
    … …  
    175177} // fmt
    176178
     179<<<<<<< HEAD
    177180inline void acquire( ofstream & os ) with(os) {
    178181        lock( lock$ );                                                                          // may increase recursive lock
    … …  
    191194void ^?{}( osacquire & acq ) { release( acq.os ); }
    192195
     196=======
     197>>>>>>> 15885de998d9500373efda8e609b893c87e6363a
    193198static ofstream soutFile = { (FILE *)stdout };
    194199ofstream & sout = soutFile, & stdout = soutFile;
    … …  
    208213        flush( os );
    209214        return os;
    210         // (ofstream &)(os | '\n');
    211         // setPrt$( os, false );                                                        // turn off
    212         // setNL$( os, true );
    213         // flush( os );
    214         // return sepOff( os );                                                 // prepare for next line
    215215} // nl
    216216
    … …  
    220220
    221221// private
    222 void ?{}( ifstream & is, void * file ) with(is) {
     222void ?{}( ifstream & is, void * file ) with( is ) {
    223223        file$ = file;
    224224        nlOnOff$ = false;
    225         acquired$ = false;
    226 } // ?{}
     225} // ?{}
     226
     227bool getANL$( ifstream & os ) { return os.nlOnOff$; }
     228
     229inline void lock( ifstream & os ) with( os ) { lock( os.lock$ ); }
     230inline void unlock( ifstream & os ) { unlock( os.lock$ ); }
    227231
    228232// public
    229233void ?{}( ifstream & is ) { is.file$ = 0p; }
    230 
    231 void ?{}( ifstream & is, const char name[], const char mode[] ) {
    232         open( is, name, mode );
    233 } // ?{}
    234 
    235 void ?{}( ifstream & is, const char name[] ) {
    236         open( is, name, "r" );
    237 } // ?{}
    238 
    239 void ^?{}( ifstream & is ) {
    240         close( is );
    241 } // ^?{}
     234void ?{}( ifstream & is, const char name[], const char mode[] ) { open( is, name, mode ); }
     235void ?{}( ifstream & is, const char name[] ) { open( is, name, "r" ); }
     236void ^?{}( ifstream & is ) { close( is ); }
     237
     238bool fail( ifstream & is ) { return is.file$ == 0p || ferror( (FILE *)(is.file$) ); }
     239void clear( ifstream & is ) { clearerr( (FILE *)(is.file$) ); }
    242240
    243241void nlOn( ifstream & os ) { os.nlOnOff$ = true; }
    244242void nlOff( ifstream & os ) { os.nlOnOff$ = false; }
    245 bool getANL( ifstream & os ) { return os.nlOnOff$; }
    246 
    247 bool fail( ifstream & is ) {
    248         return is.file$ == 0p || ferror( (FILE *)(is.file$) );
    249 } // fail
    250 
    251 void clear( ifstream & is ) {
    252         clearerr( (FILE *)(is.file$) );
    253 } // clear
    254 
    255 void ends( ifstream & is ) {
    256         if ( is.acquired$ ) { is.acquired$ = false; release( is ); }
    257 } // ends
    258 
    259 bool eof( ifstream & is ) {
    260         return feof( (FILE *)(is.file$) );
    261 } // eof
     243
     244void ends( ifstream & is ) {}
     245
     246bool eof( ifstream & is ) { return feof( (FILE *)(is.file$) ) != 0; }
    262247
    263248void open( ifstream & is, const char name[], const char mode[] ) {
    264         FILE * file = fopen( name, mode );
     249        FILE * file;
     250    for ( cnt; 10 ) {
     251                errno = 0;
     252                file = fopen( name, mode );
     253          if ( file != 0p || errno != EINTR ) break;            // timer interrupt ?
     254          if ( cnt == 9 ) abort( "ifstream open EINTR spinning exceeded" );
     255    } // for
    265256        if ( file == 0p ) {
    266257                throw (Open_Failure){ is };
    … …  
    270261} // open
    271262
    272 void open( ifstream & is, const char name[] ) {
    273         open( is, name, "r" );
    274 } // open
    275 
    276 void close( ifstream & is ) with(is) {
     263void open( ifstream & is, const char name[] ) { open( is, name, "r" ); }
     264
     265void close( ifstream & is ) with( is ) {
    277266  if ( (FILE *)(file$) == 0p ) return;
    278267  if ( (FILE *)(file$) == (FILE *)stdin ) return;
    279268
    280         if ( fclose( (FILE *)(file$) ) == EOF ) {
     269        int ret;
     270    for ( cnt; 10 ) {
     271                errno = 0;
     272                ret = fclose( (FILE *)(file$) );
     273          if ( ret != EOF || errno != EINTR ) break;            // timer interrupt ?
     274          if ( cnt == 9 ) abort( "ifstream close EINTR spinning exceeded" );
     275    } // for
     276        if ( ret == EOF ) {
    281277                throw (Close_Failure){ is };
    282278                // abort | IO_MSG "close input" | nl | strerror( errno );
    283279        } // if
    284         file$ = 0p;
     280        file$ = 0p;                                                                                     // safety after close
    285281} // close
    286282
    … …  
    311307int fmt( ifstream & is, const char format[], ... ) {
    312308        va_list args;
    313 
    314309        va_start( args, format );
    315         int len = vfscanf( (FILE *)(is.file$), format, args );
     310
     311        int len;
     312    for () {                                                                                    // no check for EINTR limit waiting for keyboard input
     313                errno = 0;
     314                len = vfscanf( (FILE *)(is.file$), format, args );
     315          if ( len != EOF || errno != EINTR ) break;            // timer interrupt ?
     316    } // for
    316317        if ( len == EOF ) {
    317318                if ( ferror( (FILE *)(is.file$) ) ) {
    … …  
    322323        return len;
    323324} // fmt
    324 
    325 inline void acquire( ifstream & is ) with(is) {
    326         lock( lock$ );                                                                          // may increase recursive lock
    327         if ( ! acquired$ ) acquired$ = true;                            // not locked ?
    328         else unlock( lock$ );                                                           // unwind recursive lock at start
    329 } // acquire
    330 
    331 inline void release( ifstream & is ) {
    332         unlock( is.lock$ );
    333 } // release
    334 
    335 void ?{}( isacquire & acq, ifstream & is ) { lock( is.lock$ ); &acq.is = &is; }
    336 void ^?{}( isacquire & acq ) { release( acq.is ); }
    337325
    338326static ifstream sinFile = { (FILE *)stdin };

  • libcfa/src/fstream.hfa

    ra51a02d ra2e4b0c  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jul 28 07:35:50 2021
    13 // Update Count     : 234
     12// Last Modified On : Sun Oct 10 09:37:32 2021
     13// Update Count     : 243
    1414//
    1515
    … …  
    3636        char tupleSeparator$[ofstream_sepSize];
    3737        multiple_acquisition_lock lock$;
    38         bool acquired$;
    3938}; // ofstream
    4039
    … …  
    5251bool getPrt$( ofstream & );
    5352void setPrt$( ofstream &, bool );
     53
     54void lock( ofstream & );
     55void unlock( ofstream & );
    5456
    5557// public
    … …  
    7577void open( ofstream &, const char name[] );
    7678void close( ofstream & );
     79
    7780ofstream & write( ofstream &, const char data[], size_t size );
    78 
    79 void acquire( ofstream & );
    80 void release( ofstream & );
    81 
    82 void lock( ofstream & );
    83 void unlock( ofstream & );
    84 
    85 struct osacquire {
    86         ofstream & os;
    87 };
    88 void ?{}( osacquire & acq, ofstream & );
    89 void ^?{}( osacquire & acq );
    9081
    9182void ?{}( ofstream & );
    … …  
    110101        bool nlOnOff$;
    111102        multiple_acquisition_lock lock$;
    112         bool acquired$;
    113103}; // ifstream
    114104
    115105// Satisfies istream
    116106
     107// private
     108bool getANL$( ifstream & );
     109
     110void lock( ifstream & );
     111void unlock( ifstream & );
     112
    117113// public
    118114void nlOn( ifstream & );
    119115void nlOff( ifstream & );
    120 bool getANL( ifstream & );
    121116void ends( ifstream & );
    122117int fmt( ifstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
    … …  
    128123void open( ifstream & is, const char name[] );
    129124void close( ifstream & is );
     125
    130126ifstream & read( ifstream & is, char data[], size_t size );
    131127ifstream & ungetc( ifstream & is, char c );
    132 
    133 void acquire( ifstream & is );
    134 void release( ifstream & is );
    135 
    136 struct isacquire {
    137         ifstream & is;
    138 };
    139 void ?{}( isacquire & acq, ifstream & is );
    140 void ^?{}( isacquire & acq );
    141128
    142129void ?{}( ifstream & is );

  • libcfa/src/iostream.cfa

    ra51a02d ra2e4b0c  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat May 15 09:39:21 2021
    13 // Update Count     : 1342
     12// Last Modified On : Sun Oct 10 09:28:17 2021
     13// Update Count     : 1345
    1414//
    1515
    … …  
    398398                return os;
    399399        } // nlOff
    400 } // distribution
    401 
    402 forall( ostype & | ostream( ostype ) ) {
    403         ostype & acquire( ostype & os ) {
    404                 acquire( os );                                                                  // call void returning
    405                 return os;
    406         } // acquire
    407400} // distribution
    408401
    … …  
    829822                        fmt( is, "%c", &temp );                                         // must pass pointer through varg to fmt
    830823                        // do not overwrite parameter with newline unless appropriate
    831                         if ( temp != '\n' || getANL( is ) ) { c = temp; break; }
     824                        if ( temp != '\n' || getANL$( is ) ) { c = temp; break; }
    832825                        if ( eof( is ) ) break;
    833826                } // for
    … …  
    10351028                return is;
    10361029        } // nlOff
    1037 } // distribution
    1038 
    1039 forall( istype & | istream( istype ) ) {
    1040         istype & acquire( istype & is ) {
    1041                 acquire( is );                                                                  // call void returning
    1042                 return is;
    1043         } // acquire
    10441030} // distribution
    10451031

  • libcfa/src/iostream.hfa

    ra51a02d ra2e4b0c  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Apr 28 20:37:56 2021
    13 // Update Count     : 401
     12// Last Modified On : Sun Oct 10 10:02:07 2021
     13// Update Count     : 407
    1414//
    1515
    … …  
    5858        void close( ostype & );
    5959        ostype & write( ostype &, const char [], size_t );
    60         void acquire( ostype & );                                                       // concurrent access
    6160}; // ostream
    6261
    … …  
    142141        ostype & nlOn( ostype & );
    143142        ostype & nlOff( ostype & );
    144 } // distribution
    145 
    146 forall( ostype & | ostream( ostype ) ) {
    147         ostype & acquire( ostype & );
    148143} // distribution
    149144
    … …  
    296291
    297292trait basic_istream( istype & ) {
    298         bool getANL( istype & );                                                        // get scan newline (on/off)
     293        // private
     294        bool getANL$( istype & );                                                       // get scan newline (on/off)
     295        // public
    299296        void nlOn( istype & );                                                          // read newline
    300297        void nlOff( istype & );                                                         // scan newline
    301 
    302298        void ends( istype & os );                                                       // end of output statement
    303299        int fmt( istype &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
    … …  
    312308        void close( istype & is );
    313309        istype & read( istype &, char [], size_t );
    314         void acquire( istype & );                                                       // concurrent access
    315310}; // istream
    316311
    … …  
    379374} // distribution
    380375
    381 forall( istype & | istream( istype ) ) {
    382         istype & acquire( istype & );
    383 } // distribution
    384 
    385376// *********************************** manipulators ***********************************
    386377

  • libcfa/src/strstream.cfa

    ra51a02d ra2e4b0c  
    1010// Created On       : Thu Apr 22 22:24:35 2021
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Apr 27 20:59:53 2021
    13 // Update Count     : 78
     12// Last Modified On : Sun Oct 10 16:13:20 2021
     13// Update Count     : 101
    1414//
    1515
    1616#include "strstream.hfa"
     17#include "fstream.hfa"                                                                  // abort
    1718
    1819#include <stdio.h>                                                                              // vsnprintf
    … …  
    3031
    3132// private
    32 bool sepPrt$( ostrstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
    33 void sepReset$( ostrstream & os ) { os.sepOnOff$ = os.sepDefault$; }
    34 void sepReset$( ostrstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
    35 const char * sepGetCur$( ostrstream & os ) { return os.sepCur$; }
    36 void sepSetCur$( ostrstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
    37 bool getNL$( ostrstream & os ) { return os.sawNL$; }
    38 void setNL$( ostrstream & os, bool state ) { os.sawNL$ = state; }
    39 bool getANL$( ostrstream & os ) { return os.nlOnOff$; }
    40 bool getPrt$( ostrstream & os ) { return os.prt$; }
    41 void setPrt$( ostrstream & os, bool state ) { os.prt$ = state; }
     33inline bool sepPrt$( ostrstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
     34inline void sepReset$( ostrstream & os ) { os.sepOnOff$ = os.sepDefault$; }
     35inline void sepReset$( ostrstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
     36inline const char * sepGetCur$( ostrstream & os ) { return os.sepCur$; }
     37inline void sepSetCur$( ostrstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
     38inline bool getNL$( ostrstream & os ) { return os.sawNL$; }
     39inline void setNL$( ostrstream & os, bool state ) { os.sawNL$ = state; }
     40inline bool getANL$( ostrstream & os ) { return os.nlOnOff$; }
     41inline bool getPrt$( ostrstream & os ) { return os.prt$; }
     42inline void setPrt$( ostrstream & os, bool state ) { os.prt$ = state; }
    4243
    4344// public
    … …  
    128129// *********************************** istrstream ***********************************
    129130
     131// private
     132bool getANL$( istrstream & is ) { return is.nlOnOff$; }
    130133
    131134// public
    … …  
    136139} // ?{}
    137140
    138 bool getANL( istrstream & is ) { return is.nlOnOff$; }
    139141void nlOn( istrstream & is ) { is.nlOnOff$ = true; }
    140142void nlOff( istrstream & is ) { is.nlOnOff$ = false; }
    141143
    142 void ends( istrstream & is ) {
    143 } // ends
     144void ends( istrstream & is ) {}
     145bool eof( istrstream & is ) { return false; }
    144146
    145 int eof( istrstream & is ) {
    146         return 0;
    147 } // eof
     147int fmt( istrstream & is, const char format[], ... ) with(is) {
     148        va_list args;
     149        va_start( args, format );
     150        // THIS DOES NOT WORK BECAUSE VSSCANF RETURNS NUMBER OF VALUES READ VERSUS BUFFER POSITION SCANNED.
     151        int len = vsscanf( buf$ + cursor$, format, args );
     152        va_end( args );
     153        if ( len == EOF ) {
     154                abort | IO_MSG "invalid read";
     155        } // if
     156        // SKULLDUGGERY: This hack skips over characters read by vsscanf by moving to the next whitespace but it does not
     157        // handle C reads with wdi manipulators that leave the cursor at a non-whitespace character.
     158        for ( ; buf$[cursor$] != ' ' && buf$[cursor$] != '\t' && buf$[cursor$] != '\0'; cursor$ += 1 ) {
     159                //printf( "X \'%c\'\n", buf$[cursor$] );
     160        } // for
     161        if ( buf$[cursor$] != '\0' ) cursor$ += 1;      // advance to whitespace
     162        return len;
     163} // fmt
    148164
    149165istrstream &ungetc( istrstream & is, char c ) {
    … …  
    154170} // ungetc
    155171
    156 int fmt( istrstream & is, const char format[], ... ) {
    157         va_list args;
    158         va_start( args, format );
    159         // This does not work because vsscanf does not return buffer position.
    160         int len = vsscanf( is.buf$ + is.cursor$, format, args );
    161         va_end( args );
    162         if ( len == EOF ) {
    163                 int j;
    164                 printf( "X %d%n\n", len, &j );
    165         } // if
    166         is.cursor$ += len;
    167         return len;
    168 } // fmt
    169 
    170172// Local Variables: //
    171173// tab-width: 4 //

  • libcfa/src/strstream.hfa

    ra51a02d ra2e4b0c  
    1010// Created On       : Thu Apr 22 22:20:59 2021
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Apr 27 20:58:50 2021
    13 // Update Count     : 41
     12// Last Modified On : Sun Oct 10 10:14:22 2021
     13// Update Count     : 47
    1414//
    1515
    … …  
    8585// Satisfies basic_istream
    8686
     87// private
     88bool getANL$( istrstream & );
     89
    8790// public
    88 bool getANL( istrstream & );
    8991void nlOn( istrstream & );
    9092void nlOff( istrstream & );
    9193void ends( istrstream & );
     94
    9295int fmt( istrstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
    93 istrstream & ungetc( istrstream & is, char c );
    94 int eof( istrstream & is );
     96istrstream & ungetc( istrstream &, char );
     97bool eof( istrstream & );
    9598
    96 void ?{}( istrstream & is, char buf[] );
     99void ?{}( istrstream &, char buf[] );
    97100
    98101// Local Variables: //
Note: See TracChangeset for help on using the changeset viewer.