Changes in / [8edbe40:50f6afb]


Ignore:
Files:
4 added
5 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/Makefile.am

    r8edbe40 r50f6afb  
    1111## Created On       : Sun May 31 08:54:01 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Wed Dec  9 22:46:14 2020
    14 ## Update Count     : 250
     13## Last Modified On : Sat Apr 24 09:09:56 2021
     14## Update Count     : 254
    1515###############################################################################
    1616
     
    6969        common.hfa \
    7070        fstream.hfa \
     71        strstream.hfa \
    7172        heap.hfa \
    7273        iostream.hfa \
  • libcfa/src/fstream.cfa

    r8edbe40 r50f6afb  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Apr 20 19:04:46 2021
    13 // Update Count     : 425
     12// Last Modified On : Sat Apr 24 09:05:16 2021
     13// Update Count     : 426
    1414//
    1515
     
    1919#include <stdlib.h>                                                                             // exit
    2020#include <stdarg.h>                                                                             // varargs
    21 #include <string.h>                                                                             // strlen
    22 #include <float.h>                                                                              // DBL_DIG, LDBL_DIG
    23 #include <complex.h>                                                                    // creal, cimag
     21#include <string.h>                                                                             // strncpy, strerror
    2422#include <assert.h>
    2523#include <errno.h>                                                                              // errno
     
    9391void sepSet( ofstream & os, const char s[] ) {
    9492        assert( s );
    95         strncpy( os.separator$, s, sepSize - 1 );
    96         os.separator$[sepSize - 1] = '\0';
     93        strncpy( os.separator$, s, ofstream_sepSize - 1 );
     94        os.separator$[ofstream_sepSize - 1] = '\0';
    9795} // sepSet
    9896
     
    10098void sepSetTuple( ofstream & os, const char s[] ) {
    10199        assert( s );
    102         strncpy( os.tupleSeparator$, s, sepSize - 1 );
    103         os.tupleSeparator$[sepSize - 1] = '\0';
     100        strncpy( os.tupleSeparator$, s, ofstream_sepSize - 1 );
     101        os.tupleSeparator$[ofstream_sepSize - 1] = '\0';
    104102} // sepSet
    105103
     
    112110} // ends
    113111
    114 int fail( ofstream & os ) {
     112bool fail( ofstream & os ) {
    115113        return os.file$ == 0 || ferror( (FILE *)(os.file$) );
    116114} // fail
     
    228226bool getANL( ifstream & os ) { return os.nlOnOff$; }
    229227
    230 int fail( ifstream & is ) {
     228bool fail( ifstream & is ) {
    231229        return is.file$ == 0p || ferror( (FILE *)(is.file$) );
    232230} // fail
  • libcfa/src/fstream.hfa

    r8edbe40 r50f6afb  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Apr 20 19:04:12 2021
    13 // Update Count     : 218
     12// Last Modified On : Sat Apr 24 09:04:03 2021
     13// Update Count     : 219
    1414//
    1515
     
    2424
    2525
    26 enum { sepSize = 16 };
     26enum { ofstream_sepSize = 16 };
    2727struct ofstream {
    2828        void * file$;
     
    3333        bool sawNL$;
    3434        const char * sepCur$;
    35         char separator$[sepSize];
    36         char tupleSeparator$[sepSize];
     35        char separator$[ofstream_sepSize];
     36        char tupleSeparator$[ofstream_sepSize];
    3737        multiple_acquisition_lock lock$;
    3838        bool acquired$;
    3939}; // ofstream
     40
     41// Satisfies ostream
    4042
    4143// private
     
    6466void sepSetTuple( ofstream &, const char [] );
    6567
    66 void ends( ofstream & os );
    67 int fail( ofstream & );
     68void ends( ofstream & );
     69int fmt( ofstream &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
     70
     71bool fail( ofstream & );
    6872int flush( ofstream & );
    6973void open( ofstream &, const char name[], const char mode[] );
     
    7175void close( ofstream & );
    7276ofstream & write( ofstream &, const char data[], size_t size );
    73 int fmt( ofstream &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
    74 void acquire( ofstream & os );
    75 void release( ofstream & os );
     77
     78void acquire( ofstream & );
     79void release( ofstream & );
    7680
    7781struct osacquire {
    7882        ofstream & os;
    7983};
    80 void ?{}( osacquire & acq, ofstream & os );
     84void ?{}( osacquire & acq, ofstream & );
    8185void ^?{}( osacquire & acq );
    8286
    83 void ?{}( ofstream & os );
    84 void ?{}( ofstream & os, const char name[], const char mode[] );
    85 void ?{}( ofstream & os, const char name[] );
    86 void ^?{}( ofstream & os );
     87void ?{}( ofstream & );
     88void ?{}( ofstream &, const char name[], const char mode[] );
     89void ?{}( ofstream &, const char name[] );
     90void ^?{}( ofstream & );
    8791
    8892extern ofstream & sout, & stdout, & serr, & stderr;             // aliases
     
    100104}; // ifstream
    101105
     106// Satisfies istream
     107
    102108// public
    103109void nlOn( ifstream & );
     
    105111bool getANL( ifstream & );
    106112void ends( ifstream & );
    107 int fail( ifstream & is );
     113bool fail( ifstream & is );
    108114int eof( ifstream & is );
    109115void open( ifstream & is, const char name[], const char mode[] );
     
    142148);
    143149
    144 void ?{}( Open_Failure & this, ofstream & ostream );
    145 void ?{}( Open_Failure & this, ifstream & istream );
     150void ?{}( Open_Failure & this, ofstream & );
     151void ?{}( Open_Failure & this, ifstream & );
    146152
    147153// Local Variables: //
  • libcfa/src/iostream.cfa

    r8edbe40 r50f6afb  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Apr 20 19:09:41 2021
    13 // Update Count     : 1325
     12// Last Modified On : Sat Apr 24 10:03:54 2021
     13// Update Count     : 1329
    1414//
    1515
     
    3636
    3737
    38 forall( ostype & | ostream( ostype ) ) {
     38forall( ostype & | basic_ostream( ostype ) ) {
    3939        ostype & ?|?( ostype & os, bool b ) {
    4040                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
     
    294294
    295295                // last character IS spacing or opening punctuation => turn off separator for next item
    296                 size_t len = strlen( s );
     296                int len = strlen( s );
    297297                ch = s[len - 1];                                                                // must make unsigned
     298                fmt( os, "%s", s );                                                             // fmt resets seperator, but reset it again
    298299                if ( sepPrt$( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
    299300                        sepOn( os );
     
    302303                } // if
    303304                if ( ch == '\n' ) setNL$( os, true );                   // check *AFTER* sepPrt$ call above as it resets NL flag
    304                 return write( os, s, len );
     305                return os;
     306//              return write( os, s, len );
    305307        } // ?|?
    306308        void ?|?( ostype & os, const char s[] ) {
     
    397399                return os;
    398400        } // nlOff
    399 
     401} // distribution
     402
     403forall( ostype & | ostream( ostype ) ) {
    400404        ostype & acquire( ostype & os ) {
    401405                acquire( os );                                                                  // call void returning
     
    445449// Default prefix for non-decimal prints is 0b, 0, 0x.
    446450#define IntegralFMTImpl( T, IFMTNP, IFMTP ) \
    447 forall( ostype & | ostream( ostype ) ) { \
     451forall( ostype & | basic_ostream( ostype ) ) { \
    448452        ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
    449453                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) ); \
     
    539543#if defined( __SIZEOF_INT128__ )
    540544// Default prefix for non-decimal prints is 0b, 0, 0x.
    541 forall( ostype & | ostream( ostype ) )
     545forall( ostype & | basic_ostream( ostype ) )
    542546static inline void base_128( ostype & os, unsigned int128 val, unsigned int128 power, _Ostream_Manip(uint64_t) & f, unsigned int maxdig, unsigned int bits, unsigned int cnt = 0 ) {
    543547        int wd = 1;                                                                                     // f.wd is never 0 because 0 implies left-pad
     
    604608
    605609#define IntegralFMTImpl128( T ) \
    606 forall( ostype & | ostream( ostype ) ) { \
     610forall( ostype & | basic_ostream( ostype ) ) { \
    607611        ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
    608612                _Ostream_Manip(uint64_t) fmt; \
     
    677681
    678682#define FloatingPointFMTImpl( T, DFMTNP, DFMTP ) \
    679 forall( ostype & | ostream( ostype ) ) { \
     683forall( ostype & | basic_ostream( ostype ) ) { \
    680684        static void eng( T &value, int & pc, int & exp10 ) { \
    681685                exp10 = lrint( floor( log10( abs( value ) ) ) ); /* round to desired precision */ \
     
    723727// *********************************** character ***********************************
    724728
    725 forall( ostype & | ostream( ostype ) ) {
     729forall( ostype & | basic_ostream( ostype ) ) {
    726730        ostype & ?|?( ostype & os, _Ostream_Manip(char) f ) {
    727731                if ( f.base != 'c' ) {                                                  // bespoke binary/octal/hex format
     
    756760// *********************************** C string ***********************************
    757761
    758 forall( ostype & | ostream( ostype ) ) {
     762forall( ostype & | basic_ostream( ostype ) ) {
    759763        ostype & ?|?( ostype & os, _Ostream_Manip(const char *) f ) {
    760764                if ( ! f.val ) return os;                                               // null pointer ?
  • libcfa/src/iostream.hfa

    r8edbe40 r50f6afb  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Apr 20 19:09:44 2021
    13 // Update Count     : 385
     12// Last Modified On : Sat Apr 24 09:28:56 2021
     13// Update Count     : 393
    1414//
    1515
     
    2222
    2323
    24 trait ostream( ostype & ) {
     24trait basic_ostream( ostype & ) {
    2525        // private
    2626        bool sepPrt$( ostype & );                                                       // get separator state (on/off)
     
    4747        void sepSetTuple( ostype &, const char [] );            // set tuple separator to string (15 character maximum)
    4848
    49         void ends( ostype & os );                                                       // end of output statement
    50         int fail( ostype & );
     49        void ends( ostype & );                                                          // end of output statement
     50        int fmt( ostype &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
    5151        int flush( ostype & );
    52         void open( ostype & os, const char name[], const char mode[] );
    53         void close( ostype & os );
     52}; // basic_ostream
     53       
     54trait ostream( ostype & | basic_ostream( ostype ) ) {
     55        bool fail( ostype & );                                                          // operation failed?
     56        void open( ostype &, const char name[], const char mode[] );
     57        void close( ostype & );
    5458        ostype & write( ostype &, const char [], size_t );
    55         int fmt( ostype &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
    56         void acquire( ostype & );
     59        void acquire( ostype & );                                                       // concurrent access
    5760}; // ostream
    5861
     
    6770// implement writable for intrinsic types
    6871
    69 forall( ostype & | ostream( ostype ) ) {
     72forall( ostype & | basic_ostream( ostype ) ) {
    7073        ostype & ?|?( ostype &, bool );
    7174        void ?|?( ostype &, bool );
     
    138141        ostype & nlOn( ostype & );
    139142        ostype & nlOff( ostype & );
     143} // distribution
     144
     145forall( ostype & | ostream( ostype ) ) {
    140146        ostype & acquire( ostype & );
    141147} // distribution
     
    196202        _Ostream_Manip(T) & sign( _Ostream_Manip(T) & fmt ) { fmt.flags.sign = true; return fmt; } \
    197203} /* distribution */ \
    198 forall( ostype & | ostream( ostype ) ) { \
     204forall( ostype & | basic_ostream( ostype ) ) { \
    199205        ostype & ?|?( ostype & os, _Ostream_Manip(T) f ); \
    200206        void ?|?( ostype & os, _Ostream_Manip(T) f ); \
     
    241247        _Ostream_Manip(T) & unit( _Ostream_Manip(T) & fmt ) { fmt.flags.nobsdp = true; return fmt; } \
    242248} /* distribution */ \
    243 forall( ostype & | ostream( ostype ) ) { \
     249forall( ostype & | basic_ostream( ostype ) ) { \
    244250        ostype & ?|?( ostype & os, _Ostream_Manip(T) f ); \
    245251        void ?|?( ostype & os, _Ostream_Manip(T) f ); \
     
    261267        _Ostream_Manip(char) & nobase( _Ostream_Manip(char) & fmt ) { fmt.flags.nobsdp = true; return fmt; }
    262268} // distribution
    263 forall( ostype & | ostream( ostype ) ) {
     269forall( ostype & | basic_ostream( ostype ) ) {
    264270        ostype & ?|?( ostype & os, _Ostream_Manip(char) f );
    265271        void ?|?( ostype & os, _Ostream_Manip(char) f );
     
    279285        _Ostream_Manip(const char *) & nobase( _Ostream_Manip(const char *) & fmt ) { fmt.flags.nobsdp = true; return fmt; }
    280286} // distribution
    281 forall( ostype & | ostream( ostype ) ) {
     287forall( ostype & | basic_ostream( ostype ) ) {
    282288        ostype & ?|?( ostype & os, _Ostream_Manip(const char *) f );
    283289        void ?|?( ostype & os, _Ostream_Manip(const char *) f );
     
    294300
    295301        void ends( istype & os );                                                       // end of output statement
    296         int fail( istype & );
     302        bool fail( istype & );
    297303        int eof( istype & );
    298304        void open( istype & is, const char name[] );
Note: See TracChangeset for help on using the changeset viewer.