Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/iostream.c

    r6ba0659 r53ba273  
    77// iostream.c --
    88//
    9 // Author           : Richard C. Bilson
     9// Author           : Peter A. Buhr
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 17 14:19:56 2016
    13 // Update Count     : 76
     12// Last Modified On : Wed Apr  6 16:13:29 2016
     13// Update Count     : 278
    1414//
    1515
    … …  
    2121#include <float.h>                                                                              // DBL_DIG, LDBL_DIG
    2222#include <complex.h>                                                                    // creal, cimag
     23#include <ctype.h>                                                                              // isspace, ispunct
    2324}
    2425
    2526forall( dtype ostype | ostream( ostype ) )
    2627ostype * ?|?( ostype *os, char c ) {
    27         return write( os, &c, 1 );
     28        prtfmt( os, "%c", c );
     29        sepOff( os );
     30        return os;
     31} // ?|?
     32
     33forall( dtype ostype | ostream( ostype ) )
     34ostype * ?|?( ostype *os, short int si ) {
     35        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
     36        sepReset( os );
     37        prtfmt( os, "%hd", si );
     38        return os;
     39} // ?|?
     40
     41forall( dtype ostype | ostream( ostype ) )
     42ostype * ?|?( ostype *os, unsigned short int usi ) {
     43        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
     44        sepReset( os );
     45        prtfmt( os, "%hu", usi );
     46        return os;
    2847} // ?|?
    2948
    3049forall( dtype ostype | ostream( ostype ) )
    3150ostype * ?|?( ostype *os, int i ) {
    32         char buffer[32];
    33         return write( os, buffer, sprintf( buffer, "%d", i ) );
    34 } // ?|?
    35 
    36 forall( dtype ostype | ostream( ostype ) )
    37 ostype * ?|?( ostype *os, unsigned int i ) {
    38         char buffer[32];
    39         return write( os, buffer, sprintf( buffer, "%u", i ) );
    40 } // ?|?
    41 
    42 forall( dtype ostype | ostream( ostype ) )
    43 ostype * ?|?( ostype *os, long int i ) {
    44         char buffer[32];
    45         return write( os, buffer, sprintf( buffer, "%ld", i ) );
    46 } // ?|?
    47 
    48 forall( dtype ostype | ostream( ostype ) )
    49 ostype * ?|?( ostype *os, long long int i ) {
    50         char buffer[32];
    51         return write( os, buffer, sprintf( buffer, "%lld", i ) );
    52 } // ?|?
    53 
    54 forall( dtype ostype | ostream( ostype ) )
    55 ostype * ?|?( ostype *os, unsigned long int i ) {
    56         char buffer[32];
    57         return write( os, buffer, sprintf( buffer, "%lu", i ) );
    58 } // ?|?
    59 
    60 forall( dtype ostype | ostream( ostype ) )
    61 ostype * ?|?( ostype *os, unsigned long long int i ) {
    62         char buffer[32];
    63         return write( os, buffer, sprintf( buffer, "%llu", i ) );
     51        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
     52        sepReset( os );
     53        prtfmt( os, "%d", i );
     54        return os;
     55} // ?|?
     56
     57forall( dtype ostype | ostream( ostype ) )
     58ostype * ?|?( ostype *os, unsigned int ui ) {
     59        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
     60        sepReset( os );
     61        prtfmt( os, "%u", ui );
     62        return os;
     63} // ?|?
     64
     65forall( dtype ostype | ostream( ostype ) )
     66ostype * ?|?( ostype *os, long int li ) {
     67        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
     68        sepReset( os );
     69        prtfmt( os, "%ld", li );
     70        return os;
     71} // ?|?
     72
     73forall( dtype ostype | ostream( ostype ) )
     74ostype * ?|?( ostype *os, unsigned long int uli ) {
     75        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
     76        sepReset( os );
     77        prtfmt( os, "%lu", uli );
     78        return os;
     79} // ?|?
     80
     81forall( dtype ostype | ostream( ostype ) )
     82ostype * ?|?( ostype *os, long long int lli ) {
     83        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
     84        sepReset( os );
     85        prtfmt( os, "%lld", lli );
     86        return os;
     87} // ?|?
     88
     89forall( dtype ostype | ostream( ostype ) )
     90ostype * ?|?( ostype *os, unsigned long long int ulli ) {
     91        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
     92        sepReset( os );
     93        prtfmt( os, "%llu", ulli );
     94        return os;
    6495} // ?|?
    6596
    6697forall( dtype ostype | ostream( ostype ) )
    6798ostype * ?|?( ostype *os, float f ) {
    68         char buffer[32];
    69         return write( os, buffer, sprintf( buffer, "%g", f ) );
     99        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
     100        sepReset( os );
     101        prtfmt( os, "%g", f );
     102        return os;
    70103} // ?|?
    71104
    72105forall( dtype ostype | ostream( ostype ) )
    73106ostype * ?|?( ostype *os, double d ) {
    74         char buffer[32];
    75         return write( os, buffer, sprintf( buffer, "%.*lg", DBL_DIG, d ) );
    76 } // ?|?
    77 
    78 forall( dtype ostype | ostream( ostype ) )
    79 ostype * ?|?( ostype *os, long double d ) {
    80         char buffer[32];
    81         return write( os, buffer, sprintf( buffer, "%.*Lg", LDBL_DIG, d ) );
    82 } // ?|?
    83 
    84 forall( dtype ostype | ostream( ostype ) )
    85 ostype * ?|?( ostype *os, float _Complex c ) {
    86         return os | crealf( c ) | (cimagf( c ) < 0 ? "" : "+") | cimagf( c ) | 'i';
    87 } // ?|?
    88 
    89 forall( dtype ostype | ostream( ostype ) )
    90 ostype * ?|?( ostype *os, double _Complex c ) {
    91         return os | creal( c ) | (cimag( c ) < 0 ? "" : "+") | cimag( c ) | 'i';
    92 } // ?|?
    93 
    94 forall( dtype ostype | ostream( ostype ) )
    95 ostype * ?|?( ostype *os, long double _Complex c ) {
    96         return os | creall( c ) | (cimagl( c ) < 0 ? "" : "+") | cimagl( c ) | 'i';
     107        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
     108        sepReset( os );
     109        prtfmt( os, "%.*lg", DBL_DIG, d );
     110        return os;
     111} // ?|?
     112
     113forall( dtype ostype | ostream( ostype ) )
     114ostype * ?|?( ostype *os, long double ld ) {
     115        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
     116        sepReset( os );
     117        prtfmt( os, "%.*Lg", LDBL_DIG, ld );
     118        return os;
     119} // ?|?
     120
     121forall( dtype ostype | ostream( ostype ) )
     122ostype * ?|?( ostype *os, float _Complex fc ) {
     123        os | crealf( fc );
     124        _Bool temp = sepDisable( os );                                          // disable separators within complex value
     125        if ( cimagf( fc ) >= 0 ) os | '+';                                      // negative value prints '-'
     126        os | cimagf( fc ) | 'i';
     127        sepReset( os, temp );                                                           // reset separator
     128        return os;
     129} // ?|?
     130
     131forall( dtype ostype | ostream( ostype ) )
     132ostype * ?|?( ostype *os, double _Complex dc ) {
     133        os | creal( dc );
     134        _Bool temp = sepDisable( os );                                          // disable separators within complex value
     135        if ( cimag( dc ) >= 0 ) os | '+';                                       // negative value prints '-'
     136        os | cimag( dc ) | 'i';
     137        sepReset( os, temp );                                                           // reset separator
     138        return os;
     139} // ?|?
     140
     141forall( dtype ostype | ostream( ostype ) )
     142ostype * ?|?( ostype *os, long double _Complex ldc ) {
     143        os | creall( ldc );
     144        _Bool temp = sepDisable( os );                                          // disable separators within complex value
     145        if ( cimagl( ldc ) >= 0 ) os | '+';                                     // negative value prints '-'
     146        os | cimagl( ldc ) | 'i';
     147        sepReset( os, temp );                                                           // reset separator
     148        return os;
     149} // ?|?
     150
     151forall( dtype ostype | ostream( ostype ) )
     152ostype * ?|?( ostype *os, const char *cp ) {
     153        enum { Open = 1, Close, OpenClose };
     154        static const unsigned char mask[256] = {
     155                // opening delimiters
     156                ['('] : Open, ['['] : Open, ['{'] : Open,
     157                ['$'] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open, [(unsigned char)'¿'] : Open, [(unsigned char)'«'] : Open,
     158                // closing delimiters
     159                [','] : Close, ['.'] : Close, [':'] : Close, [';'] : Close, ['!'] : Close, ['?'] : Close,
     160                [')'] : Close, [']'] : Close, ['}'] : Close,
     161                ['%'] : Close, [(unsigned char)'¢'] : Close, [(unsigned char)'»'] : Close,
     162                // opening-closing delimiters
     163                ['\''] : OpenClose, ['`'] : OpenClose, ['"'] : OpenClose,
     164                ['\f'] : OpenClose, ['\n'] : OpenClose, ['\r'] : OpenClose, ['\t'] : OpenClose, ['\v'] : OpenClose, // isspace
     165        }; // mask
     166
     167        int len = strlen( cp );
     168        // null string => no separator
     169  if ( len == 0 ) { sepOff( os ); return os; }
     170        // first character IS NOT spacing or closing punctuation => add left separator
     171        unsigned char ch = cp[0];                                                       // must make unsigned
     172        if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
     173                prtfmt( os, "%s", sepGet( os ) );
     174        } // if
     175        // last character IS spacing or opening punctuation => turn off separator for next item
     176        unsigned int posn = len - 1;
     177        ch = cp[posn];                                                                          // must make unsigned
     178        if ( mask[ ch ] == Open || mask[ ch ] == OpenClose ) {
     179                sepOff( os );
     180        } else {
     181                sepOn( os );
     182        } // if
     183        return write( os, cp, len );
    97184} // ?|?
    98185
    99186forall( dtype ostype | ostream( ostype ) )
    100187ostype * ?|?( ostype *os, const void *p ) {
    101         char buffer[32];
    102         return write( os, buffer, sprintf( buffer, "%p", p ) );
    103 } // ?|?
    104 
    105 forall( dtype ostype | ostream( ostype ) )
    106 ostype * ?|?( ostype *os, const char *cp ) {
    107         return write( os, cp, strlen( cp ) );
    108 } // ?|?
    109 
    110 
    111 forall( dtype ostype, dtype retostype | ostream( ostype ) | ostream( retostype ) )
    112 retostype * ?|?( ostype *os, retostype * (*manip)(ostype*) ) {
    113   return manip( os );
    114 }
     188        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
     189        sepReset( os );
     190        prtfmt( os, "%p", p );
     191        return os;
     192} // ?|?
     193
     194
     195forall( dtype ostype | ostream( ostype ) )
     196ostype * ?|?( ostype *os, ostype * (* manip)( ostype * ) ) {
     197        return manip( os );
     198} // ?|?
    115199
    116200forall( dtype ostype | ostream( ostype ) )
    117201ostype * endl( ostype * os ) {
    118         os | "\n";
     202        os | '\n';
    119203        flush( os );
     204        sepOff( os );
    120205        return os;
    121206} // endl
    122207
     208forall( dtype ostype | ostream( ostype ) )
     209ostype * sepOn( ostype * os ) {
     210        sepOn( os );
     211        return os;
     212} // sepOn
     213
     214forall( dtype ostype | ostream( ostype ) )
     215ostype * sepOff( ostype * os ) {
     216        sepOff( os );
     217        return os;
     218} // sepOff
     219
     220forall( dtype ostype | ostream( ostype ) )
     221ostype * sepEnable( ostype * os ) {
     222        sepEnable( os );
     223        return os;
     224} // sepEnable
     225
     226forall( dtype ostype | ostream( ostype ) )
     227ostype * sepDisable( ostype * os ) {
     228        sepDisable( os );
     229        return os;
     230} // sepDisable
     231
    123232//---------------------------------------
    124233
    125 forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ),
    126                 dtype os_type | ostream( os_type ) )
    127 void write( iterator_type begin, iterator_type end, os_type *os ) {
    128         void print( elt_type i ) { os | i | ' '; }
     234forall( otype elttype | writeable( elttype ), otype iteratortype | iterator( iteratortype, elttype ), dtype ostype | ostream( ostype ) )
     235void write( iteratortype begin, iteratortype end, ostype *os ) {
     236        void print( elttype i ) { os | i; }
    129237        for_each( begin, end, print );
    130238} // ?|?
    131239
    132 forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ),
    133                 dtype os_type | ostream( os_type ) )
    134 void write_reverse( iterator_type begin, iterator_type end, os_type *os ) {
    135         void print( elt_type i ) { os | i | ' '; }
     240forall( otype elttype | writeable( elttype ), otype iteratortype | iterator( iteratortype, elttype ), dtype ostype | ostream( ostype ) )
     241void write_reverse( iteratortype begin, iteratortype end, ostype *os ) {
     242        void print( elttype i ) { os | i; }
    136243        for_each_reverse( begin, end, print );
    137244} // ?|?
    … …  
    140247
    141248forall( dtype istype | istream( istype ) )
    142 istype * ?|?( istype *is, char *cp ) {
    143         return read( is, cp, 1 );
    144 } // ?|?
    145 
    146 forall( dtype istype | istream( istype ) )
    147 istype * ?|?( istype *is, int *ip ) {
    148         return get( is, ip );
    149 } // ?|?
     249istype * ?|?( istype * is, char * c ) {
     250        scanfmt( is, "%c", c );
     251        return is;
     252} // ?|?
     253
     254forall( dtype istype | istream( istype ) )
     255istype * ?|?( istype * is, short int * si ) {
     256        scanfmt( is, "%hd", si );
     257        return is;
     258} // ?|?
     259
     260forall( dtype istype | istream( istype ) )
     261istype * ?|?( istype * is, unsigned short int * usi ) {
     262        scanfmt( is, "%hu", usi );
     263        return is;
     264} // ?|?
     265
     266forall( dtype istype | istream( istype ) )
     267istype * ?|?( istype * is, int * i ) {
     268        scanfmt( is, "%d", i );
     269        return is;
     270} // ?|?
     271
     272forall( dtype istype | istream( istype ) )
     273istype * ?|?( istype * is, unsigned int * ui ) {
     274        scanfmt( is, "%u", ui );
     275        return is;
     276} // ?|?
     277
     278forall( dtype istype | istream( istype ) )
     279istype * ?|?( istype * is, long int * li ) {
     280        scanfmt( is, "%ld", li );
     281        return is;
     282} // ?|?
     283
     284forall( dtype istype | istream( istype ) )
     285istype * ?|?( istype * is, unsigned long int * ulli ) {
     286        scanfmt( is, "%lu", ulli );
     287        return is;
     288} // ?|?
     289
     290forall( dtype istype | istream( istype ) )
     291istype * ?|?( istype * is, long long int * lli ) {
     292        scanfmt( is, "%lld", lli );
     293        return is;
     294} // ?|?
     295
     296forall( dtype istype | istream( istype ) )
     297istype * ?|?( istype * is, unsigned long long int * ulli ) {
     298        scanfmt( is, "%llu", ulli );
     299        return is;
     300} // ?|?
     301
     302
     303forall( dtype istype | istream( istype ) )
     304istype * ?|?( istype * is, float * f ) {
     305        scanfmt( is, "%f", f );
     306        return is;
     307} // ?|?
     308
     309forall( dtype istype | istream( istype ) )
     310istype * ?|?( istype * is, double * d ) {
     311        scanfmt( is, "%lf", d );
     312        return is;
     313} // ?|?
     314
     315forall( dtype istype | istream( istype ) )
     316istype * ?|?( istype * is, long double * ld ) {
     317        scanfmt( is, "%Lf", ld );
     318        return is;
     319} // ?|?
     320
     321
     322forall( dtype istype | istream( istype ) )
     323istype * ?|?( istype * is, float _Complex * fc ) {
     324        float re, im;
     325        scanfmt( is, "%g%gi", &re, &im );
     326        *fc = re + im * _Complex_I;
     327        return is;
     328} // ?|?
     329
     330forall( dtype istype | istream( istype ) )
     331istype * ?|?( istype * is, double _Complex * dc ) {
     332        double re, im;
     333        scanfmt( is, "%lf%lfi", &re, &im );
     334        *dc = re + im * _Complex_I;
     335        return is;
     336} // ?|?
     337
     338forall( dtype istype | istream( istype ) )
     339istype * ?|?( istype * is, long double _Complex * ldc ) {
     340        long double re, im;
     341        scanfmt( is, "%Lf%Lfi", &re, &im );
     342        *ldc = re + im * _Complex_I;
     343        return is;
     344} // ?|?
     345
     346_Istream_cstrUC cstr( char * s ) { _Istream_cstrUC s = { s }; return s; }
     347forall( dtype istype | istream( istype ) )
     348istype * ?|?( istype * is, _Istream_cstrUC cstr ) {
     349        scanfmt( is, "%s", cstr.s );
     350        return is;
     351} // cstr
     352
     353_Istream_cstrC cstr( char * s, int size ) { _Istream_cstrC s = { s, size }; return s; }
     354forall( dtype istype | istream( istype ) )
     355istype * ?|?( istype * is, _Istream_cstrC cstr ) {
     356        char buf[16];
     357        sprintf( buf, "%%%ds", cstr.size );
     358        scanfmt( is, buf, cstr.s );
     359        return is;
     360} // cstr
    150361
    151362// Local Variables: //
Note: See TracChangeset for help on using the changeset viewer.