Changeset 6c5d92f


Ignore:
Timestamp:
Apr 20, 2021, 9:32:28 PM (5 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
6f6b844
Parents:
59f3f61
Message:

for private variables and functions, move prefix $ to suffix $

Location:
libcfa/src
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/fstream.cfa

    r59f3f61 r6c5d92f  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar  1 21:12:15 2021
    13 // Update Count     : 424
     12// Last Modified On : Tue Apr 20 19:04:46 2021
     13// Update Count     : 425
    1414//
    1515
     
    3131
    3232void ?{}( ofstream & os, void * file ) {
    33         os.$file = file;
    34         os.$sepDefault = true;
    35         os.$sepOnOff = false;
    36         os.$nlOnOff = true;
    37         os.$prt = false;
    38         os.$sawNL = false;
    39         os.$acquired = false;
    40         $sepSetCur( os, sepGet( os ) );
     33        os.file$ = file;
     34        os.sepDefault$ = true;
     35        os.sepOnOff$ = false;
     36        os.nlOnOff$ = true;
     37        os.prt$ = false;
     38        os.sawNL$ = false;
     39        os.acquired$ = false;
     40        sepSetCur$( os, sepGet( os ) );
    4141        sepSet( os, " " );
    4242        sepSetTuple( os, ", " );
     
    4444
    4545// private
    46 bool $sepPrt( ofstream & os ) { $setNL( os, false ); return os.$sepOnOff; }
    47 void $sepReset( ofstream & os ) { os.$sepOnOff = os.$sepDefault; }
    48 void $sepReset( ofstream & os, bool reset ) { os.$sepDefault = reset; os.$sepOnOff = os.$sepDefault; }
    49 const char * $sepGetCur( ofstream & os ) { return os.$sepCur; }
    50 void $sepSetCur( ofstream & os, const char sepCur[] ) { os.$sepCur = sepCur; }
    51 bool $getNL( ofstream & os ) { return os.$sawNL; }
    52 void $setNL( ofstream & os, bool state ) { os.$sawNL = state; }
    53 bool $getANL( ofstream & os ) { return os.$nlOnOff; }
    54 bool $getPrt( ofstream & os ) { return os.$prt; }
    55 void $setPrt( ofstream & os, bool state ) { os.$prt = state; }
     46bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
     47void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
     48void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
     49const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
     50void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
     51bool getNL$( ofstream & os ) { return os.sawNL$; }
     52void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
     53bool getANL$( ofstream & os ) { return os.nlOnOff$; }
     54bool getPrt$( ofstream & os ) { return os.prt$; }
     55void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
    5656
    5757// public
    58 void ?{}( ofstream & os ) { os.$file = 0p; }
     58void ?{}( ofstream & os ) { os.file$ = 0p; }
    5959
    6060void ?{}( ofstream & os, const char name[], const char mode[] ) {
     
    7070} // ^?{}
    7171
    72 void sepOn( ofstream & os ) { os.$sepOnOff = ! $getNL( os ); }
    73 void sepOff( ofstream & os ) { os.$sepOnOff = false; }
     72void sepOn( ofstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
     73void sepOff( ofstream & os ) { os.sepOnOff$ = false; }
    7474
    7575bool sepDisable( ofstream & os ) {
    76         bool temp = os.$sepDefault;
    77         os.$sepDefault = false;
    78         $sepReset( os );
     76        bool temp = os.sepDefault$;
     77        os.sepDefault$ = false;
     78        sepReset$( os );
    7979        return temp;
    8080} // sepDisable
    8181
    8282bool sepEnable( ofstream & os ) {
    83         bool temp = os.$sepDefault;
    84         os.$sepDefault = true;
    85         if ( os.$sepOnOff ) $sepReset( os );                            // start of line ?
     83        bool temp = os.sepDefault$;
     84        os.sepDefault$ = true;
     85        if ( os.sepOnOff$ ) sepReset$( os );                            // start of line ?
    8686        return temp;
    8787} // sepEnable
    8888
    89 void nlOn( ofstream & os ) { os.$nlOnOff = true; }
    90 void nlOff( ofstream & os ) { os.$nlOnOff = false; }
    91 
    92 const char * sepGet( ofstream & os ) { return os.$separator; }
     89void nlOn( ofstream & os ) { os.nlOnOff$ = true; }
     90void nlOff( ofstream & os ) { os.nlOnOff$ = false; }
     91
     92const char * sepGet( ofstream & os ) { return os.separator$; }
    9393void sepSet( ofstream & os, const char s[] ) {
    9494        assert( s );
    95         strncpy( os.$separator, s, sepSize - 1 );
    96         os.$separator[sepSize - 1] = '\0';
     95        strncpy( os.separator$, s, sepSize - 1 );
     96        os.separator$[sepSize - 1] = '\0';
    9797} // sepSet
    9898
    99 const char * sepGetTuple( ofstream & os ) { return os.$tupleSeparator; }
     99const char * sepGetTuple( ofstream & os ) { return os.tupleSeparator$; }
    100100void sepSetTuple( ofstream & os, const char s[] ) {
    101101        assert( s );
    102         strncpy( os.$tupleSeparator, s, sepSize - 1 );
    103         os.$tupleSeparator[sepSize - 1] = '\0';
     102        strncpy( os.tupleSeparator$, s, sepSize - 1 );
     103        os.tupleSeparator$[sepSize - 1] = '\0';
    104104} // sepSet
    105105
    106106void ends( ofstream & os ) {
    107         if ( $getANL( os ) ) nl( os );
    108         else $setPrt( os, false );                                                      // turn off
     107        if ( getANL$( os ) ) nl( os );
     108        else setPrt$( os, false );                                                      // turn off
    109109        if ( &os == &exit ) exit( EXIT_FAILURE );
    110110        if ( &os == &abort ) abort();
    111         if ( os.$acquired ) { os.$acquired = false; release( os ); }
     111        if ( os.acquired$ ) { os.acquired$ = false; release( os ); }
    112112} // ends
    113113
    114114int fail( ofstream & os ) {
    115         return os.$file == 0 || ferror( (FILE *)(os.$file) );
     115        return os.file$ == 0 || ferror( (FILE *)(os.file$) );
    116116} // fail
    117117
    118118int flush( ofstream & os ) {
    119         return fflush( (FILE *)(os.$file) );
     119        return fflush( (FILE *)(os.file$) );
    120120} // flush
    121121
     
    136136
    137137void close( ofstream & os ) {
    138   if ( (FILE *)(os.$file) == 0p ) return;
    139   if ( (FILE *)(os.$file) == (FILE *)stdout || (FILE *)(os.$file) == (FILE *)stderr ) return;
    140 
    141         if ( fclose( (FILE *)(os.$file) ) == EOF ) {
     138  if ( (FILE *)(os.file$) == 0p ) return;
     139  if ( (FILE *)(os.file$) == (FILE *)stdout || (FILE *)(os.file$) == (FILE *)stderr ) return;
     140
     141        if ( fclose( (FILE *)(os.file$) ) == EOF ) {
    142142                abort | IO_MSG "close output" | nl | strerror( errno );
    143143        } // if
    144         os.$file = 0p;
     144        os.file$ = 0p;
    145145} // close
    146146
     
    150150        } // if
    151151
    152         if ( fwrite( data, 1, size, (FILE *)(os.$file) ) != size ) {
     152        if ( fwrite( data, 1, size, (FILE *)(os.file$) ) != size ) {
    153153                abort | IO_MSG "write" | nl | strerror( errno );
    154154        } // if
     
    159159        va_list args;
    160160        va_start( args, format );
    161         int len = vfprintf( (FILE *)(os.$file), format, args );
     161        int len = vfprintf( (FILE *)(os.file$), format, args );
    162162        if ( len == EOF ) {
    163                 if ( ferror( (FILE *)(os.$file) ) ) {
     163                if ( ferror( (FILE *)(os.file$) ) ) {
    164164                        abort | IO_MSG "invalid write";
    165165                } // if
     
    167167        va_end( args );
    168168
    169         $setPrt( os, true );                                                            // called in output cascade
    170         $sepReset( os );                                                                        // reset separator
     169        setPrt$( os, true );                                                            // called in output cascade
     170        sepReset$( os );                                                                        // reset separator
    171171        return len;
    172172} // fmt
    173173
    174174inline void acquire( ofstream & os ) {
    175         lock( os.$lock );
    176         if ( ! os.$acquired ) os.$acquired = true;
    177         else unlock( os.$lock );
     175        lock( os.lock$ );
     176        if ( ! os.acquired$ ) os.acquired$ = true;
     177        else unlock( os.lock$ );
    178178} // acquire
    179179
    180180inline void release( ofstream & os ) {
    181         unlock( os.$lock );
     181        unlock( os.lock$ );
    182182} // release
    183183
    184 void ?{}( osacquire & acq, ofstream & os ) { &acq.os = &os; lock( os.$lock ); }
     184void ?{}( osacquire & acq, ofstream & os ) { &acq.os = &os; lock( os.lock$ ); }
    185185void ^?{}( osacquire & acq ) { release( acq.os ); }
    186186
     
    204204// private
    205205void ?{}( ifstream & is, void * file ) {
    206         is.$file = file;
    207         is.$nlOnOff = false;
    208         is.$acquired = false;
     206        is.file$ = file;
     207        is.nlOnOff$ = false;
     208        is.acquired$ = false;
    209209} // ?{}
    210210
    211211// public
    212 void ?{}( ifstream & is ) { is.$file = 0p; }
     212void ?{}( ifstream & is ) { is.file$ = 0p; }
    213213
    214214void ?{}( ifstream & is, const char name[], const char mode[] ) {
     
    224224} // ^?{}
    225225
    226 void nlOn( ifstream & os ) { os.$nlOnOff = true; }
    227 void nlOff( ifstream & os ) { os.$nlOnOff = false; }
    228 bool getANL( ifstream & os ) { return os.$nlOnOff; }
     226void nlOn( ifstream & os ) { os.nlOnOff$ = true; }
     227void nlOff( ifstream & os ) { os.nlOnOff$ = false; }
     228bool getANL( ifstream & os ) { return os.nlOnOff$; }
    229229
    230230int fail( ifstream & is ) {
    231         return is.$file == 0p || ferror( (FILE *)(is.$file) );
     231        return is.file$ == 0p || ferror( (FILE *)(is.file$) );
    232232} // fail
    233233
    234234void ends( ifstream & is ) {
    235         if ( is.$acquired ) { is.$acquired = false; release( is ); }
     235        if ( is.acquired$ ) { is.acquired$ = false; release( is ); }
    236236} // ends
    237237
    238238int eof( ifstream & is ) {
    239         return feof( (FILE *)(is.$file) );
     239        return feof( (FILE *)(is.file$) );
    240240} // eof
    241241
     
    248248        } // if
    249249        #endif // __CFA_DEBUG__
    250         is.$file = file;
     250        is.file$ = file;
    251251} // open
    252252
     
    256256
    257257void close( ifstream & is ) {
    258   if ( (FILE *)(is.$file) == 0p ) return;
    259   if ( (FILE *)(is.$file) == (FILE *)stdin ) return;
    260 
    261         if ( fclose( (FILE *)(is.$file) ) == EOF ) {
     258  if ( (FILE *)(is.file$) == 0p ) return;
     259  if ( (FILE *)(is.file$) == (FILE *)stdin ) return;
     260
     261        if ( fclose( (FILE *)(is.file$) ) == EOF ) {
    262262                abort | IO_MSG "close input" | nl | strerror( errno );
    263263        } // if
    264         is.$file = 0p;
     264        is.file$ = 0p;
    265265} // close
    266266
     
    270270        } // if
    271271
    272         if ( fread( data, size, 1, (FILE *)(is.$file) ) == 0 ) {
     272        if ( fread( data, size, 1, (FILE *)(is.file$) ) == 0 ) {
    273273                abort | IO_MSG "read" | nl | strerror( errno );
    274274        } // if
     
    281281        } // if
    282282
    283         if ( ungetc( c, (FILE *)(is.$file) ) == EOF ) {
     283        if ( ungetc( c, (FILE *)(is.file$) ) == EOF ) {
    284284                abort | IO_MSG "ungetc" | nl | strerror( errno );
    285285        } // if
     
    291291
    292292        va_start( args, format );
    293         int len = vfscanf( (FILE *)(is.$file), format, args );
     293        int len = vfscanf( (FILE *)(is.file$), format, args );
    294294        if ( len == EOF ) {
    295                 if ( ferror( (FILE *)(is.$file) ) ) {
     295                if ( ferror( (FILE *)(is.file$) ) ) {
    296296                        abort | IO_MSG "invalid read";
    297297                } // if
     
    302302
    303303inline void acquire( ifstream & is ) {
    304         lock( is.$lock );
    305         if ( ! is.$acquired ) is.$acquired = true;
    306         else unlock( is.$lock );
     304        lock( is.lock$ );
     305        if ( ! is.acquired$ ) is.acquired$ = true;
     306        else unlock( is.lock$ );
    307307} // acquire
    308308
    309309inline void release( ifstream & is ) {
    310         unlock( is.$lock );
     310        unlock( is.lock$ );
    311311} // release
    312312
    313 void ?{}( isacquire & acq, ifstream & is ) { &acq.is = &is; lock( is.$lock ); }
     313void ?{}( isacquire & acq, ifstream & is ) { &acq.is = &is; lock( is.lock$ ); }
    314314void ^?{}( isacquire & acq ) { release( acq.is ); }
    315315
  • libcfa/src/fstream.hfa

    r59f3f61 r6c5d92f  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar  1 22:45:08 2021
    13 // Update Count     : 217
     12// Last Modified On : Tue Apr 20 19:04:12 2021
     13// Update Count     : 218
    1414//
    1515
     
    2626enum { sepSize = 16 };
    2727struct ofstream {
    28         void * $file;
    29         bool $sepDefault;
    30         bool $sepOnOff;
    31         bool $nlOnOff;
    32         bool $prt;                                                                                      // print text
    33         bool $sawNL;
    34         const char * $sepCur;
    35         char $separator[sepSize];
    36         char $tupleSeparator[sepSize];
    37         multiple_acquisition_lock $lock;
    38         bool $acquired;
     28        void * file$;
     29        bool sepDefault$;
     30        bool sepOnOff$;
     31        bool nlOnOff$;
     32        bool prt$;                                                                                      // print text
     33        bool sawNL$;
     34        const char * sepCur$;
     35        char separator$[sepSize];
     36        char tupleSeparator$[sepSize];
     37        multiple_acquisition_lock lock$;
     38        bool acquired$;
    3939}; // ofstream
    4040
    4141// private
    42 bool $sepPrt( ofstream & );
    43 void $sepReset( ofstream & );
    44 void $sepReset( ofstream &, bool );
    45 const char * $sepGetCur( ofstream & );
    46 void $sepSetCur( ofstream &, const char [] );
    47 bool $getNL( ofstream & );
    48 void $setNL( ofstream &, bool );
    49 bool $getANL( ofstream & );
    50 bool $getPrt( ofstream & );
    51 void $setPrt( ofstream &, bool );
     42bool sepPrt$( ofstream & );
     43void sepReset$( ofstream & );
     44void sepReset$( ofstream &, bool );
     45const char * sepGetCur$( ofstream & );
     46void sepSetCur$( ofstream &, const char [] );
     47bool getNL$( ofstream & );
     48void setNL$( ofstream &, bool );
     49bool getANL$( ofstream & );
     50bool getPrt$( ofstream & );
     51void setPrt$( ofstream &, bool );
    5252
    5353// public
     
    9494
    9595struct ifstream {
    96         void * $file;
    97         bool $nlOnOff;
    98         multiple_acquisition_lock $lock;
    99         bool $acquired;
     96        void * file$;
     97        bool nlOnOff$;
     98        multiple_acquisition_lock lock$;
     99        bool acquired$;
    100100}; // ifstream
    101101
  • libcfa/src/gmp.hfa

    r59f3f61 r6c5d92f  
    1010// Created On       : Tue Apr 19 08:43:43 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb  9 09:56:54 2020
    13 // Update Count     : 31
     12// Last Modified On : Tue Apr 20 20:59:21 2021
     13// Update Count     : 32
    1414//
    1515
     
    263263        forall( ostype & | ostream( ostype ) ) {
    264264                ostype & ?|?( ostype & os, Int mp ) {
    265                         if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     265                        if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    266266                        gmp_printf( "%Zd", mp.mpz );
    267267                        sepOn( os );
  • libcfa/src/heap.cfa

    r59f3f61 r6c5d92f  
    1010// Created On       : Tue Dec 19 21:58:35 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Mar 14 10:39:24 2021
    13 // Update Count     : 1032
     12// Last Modified On : Tue Apr 20 21:20:48 2021
     13// Update Count     : 1033
    1414//
    1515
     
    11281128
    11291129        // Set the alignment for an the allocation and return previous alignment or 0 if no alignment.
    1130         size_t $malloc_alignment_set( void * addr, size_t alignment ) {
     1130        size_t malloc_alignment_set$( void * addr, size_t alignment ) {
    11311131          if ( unlikely( addr == 0p ) ) return libAlign();      // minimum alignment
    11321132                size_t ret;
     
    11391139                } // if
    11401140                return ret;
    1141         } // $malloc_alignment_set
     1141        } // malloc_alignment_set$
    11421142
    11431143
     
    11531153
    11541154        // Set allocation is zero filled and return previous zero filled.
    1155         bool $malloc_zero_fill_set( void * addr ) {
     1155        bool malloc_zero_fill_set$( void * addr ) {
    11561156          if ( unlikely( addr == 0p ) ) return false;           // null allocation is not zero fill
    11571157                HeapManager.Storage.Header * header = headerAddr( addr );
     
    11621162                header->kind.real.blockSize |= 2;                               // mark as zero filled
    11631163                return ret;
    1164         } // $malloc_zero_fill_set
     1164        } // malloc_zero_fill_set$
    11651165
    11661166
     
    11761176
    11771177        // Set allocation size and return previous size.
    1178         size_t $malloc_size_set( void * addr, size_t size ) {
     1178        size_t malloc_size_set$( void * addr, size_t size ) {
    11791179          if ( unlikely( addr == 0p ) ) return 0;                       // null allocation has 0 size
    11801180                HeapManager.Storage.Header * header = headerAddr( addr );
     
    11851185                header->kind.real.size = size;
    11861186                return ret;
    1187         } // $malloc_size_set
     1187        } // malloc_size_set$
    11881188
    11891189
  • libcfa/src/iostream.cfa

    r59f3f61 r6c5d92f  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Apr 13 13:05:24 2021
    13 // Update Count     : 1324
     12// Last Modified On : Tue Apr 20 19:09:41 2021
     13// Update Count     : 1325
    1414//
    1515
     
    3838forall( ostype & | ostream( ostype ) ) {
    3939        ostype & ?|?( ostype & os, bool b ) {
    40                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     40                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    4141                fmt( os, "%s", b ? "true" : "false" );
    4242                return os;
     
    4848        ostype & ?|?( ostype & os, char c ) {
    4949                fmt( os, "%c", c );
    50                 if ( c == '\n' ) $setNL( os, true );
     50                if ( c == '\n' ) setNL$( os, true );
    5151                return sepOff( os );
    5252        } // ?|?
     
    5656
    5757        ostype & ?|?( ostype & os, signed char sc ) {
    58                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     58                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    5959                fmt( os, "%hhd", sc );
    6060                return os;
     
    6565
    6666        ostype & ?|?( ostype & os, unsigned char usc ) {
    67                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     67                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    6868                fmt( os, "%hhu", usc );
    6969                return os;
     
    7474
    7575        ostype & ?|?( ostype & os, short int si ) {
    76                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     76                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    7777                fmt( os, "%hd", si );
    7878                return os;
     
    8383
    8484        ostype & ?|?( ostype & os, unsigned short int usi ) {
    85                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     85                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    8686                fmt( os, "%hu", usi );
    8787                return os;
     
    9292
    9393        ostype & ?|?( ostype & os, int i ) {
    94                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     94                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    9595                fmt( os, "%d", i );
    9696                return os;
     
    101101
    102102        ostype & ?|?( ostype & os, unsigned int ui ) {
    103                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     103                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    104104                fmt( os, "%u", ui );
    105105                return os;
     
    110110
    111111        ostype & ?|?( ostype & os, long int li ) {
    112                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     112                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    113113                fmt( os, "%ld", li );
    114114                return os;
     
    119119
    120120        ostype & ?|?( ostype & os, unsigned long int uli ) {
    121                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     121                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    122122                fmt( os, "%lu", uli );
    123123                return os;
     
    128128
    129129        ostype & ?|?( ostype & os, long long int lli ) {
    130                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     130                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    131131                fmt( os, "%lld", lli );
    132132                return os;
     
    137137
    138138        ostype & ?|?( ostype & os, unsigned long long int ulli ) {
    139                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     139                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    140140                fmt( os, "%llu", ulli );
    141141                return os;
     
    171171
    172172        ostype & ?|?( ostype & os, int128 llli ) {
    173                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     173                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    174174                base10_128( os, llli );
    175175                return os;
     
    180180
    181181        ostype & ?|?( ostype & os, unsigned int128 ullli ) {
    182                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     182                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    183183                base10_128( os, ullli );
    184184                return os;
     
    204204
    205205        ostype & ?|?( ostype & os, float f ) {
    206                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     206                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    207207                PrintWithDP( os, "%g", f );
    208208                return os;
     
    213213
    214214        ostype & ?|?( ostype & os, double d ) {
    215                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     215                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    216216                PrintWithDP( os, "%.*lg", d, DBL_DIG );
    217217                return os;
     
    222222
    223223        ostype & ?|?( ostype & os, long double ld ) {
    224                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     224                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    225225                PrintWithDP( os, "%.*Lg", ld, LDBL_DIG );
    226226                return os;
     
    231231
    232232        ostype & ?|?( ostype & os, float _Complex fc ) {
    233                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     233                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    234234//              os | crealf( fc ) | nonl;
    235235                PrintWithDP( os, "%g", crealf( fc ) );
     
    243243
    244244        ostype & ?|?( ostype & os, double _Complex dc ) {
    245                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     245                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    246246//              os | creal( dc ) | nonl;
    247247                PrintWithDP( os, "%.*lg", creal( dc ), DBL_DIG );
     
    255255
    256256        ostype & ?|?( ostype & os, long double _Complex ldc ) {
    257                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     257                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    258258//              os | creall( ldc ) || nonl;
    259259                PrintWithDP( os, "%.*Lg", creall( ldc ), LDBL_DIG );
     
    286286                // first character IS NOT spacing or closing punctuation => add left separator
    287287                unsigned char ch = s[0];                                                // must make unsigned
    288                 if ( $sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
    289                         fmt( os, "%s", $sepGetCur( os ) );
     288                if ( sepPrt$( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
     289                        fmt( os, "%s", sepGetCur$( os ) );
    290290                } // if
    291291
    292292                // if string starts line, must reset to determine open state because separator is off
    293                 $sepReset( os );                                                                // reset separator
     293                sepReset$( os );                                                                // reset separator
    294294
    295295                // last character IS spacing or opening punctuation => turn off separator for next item
    296296                size_t len = strlen( s );
    297297                ch = s[len - 1];                                                                // must make unsigned
    298                 if ( $sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
     298                if ( sepPrt$( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
    299299                        sepOn( os );
    300300                } else {
    301301                        sepOff( os );
    302302                } // if
    303                 if ( ch == '\n' ) $setNL( os, true );                   // check *AFTER* $sepPrt call above as it resets NL flag
     303                if ( ch == '\n' ) setNL$( os, true );                   // check *AFTER* sepPrt$ call above as it resets NL flag
    304304                return write( os, s, len );
    305305        } // ?|?
     
    309309
    310310//      ostype & ?|?( ostype & os, const char16_t * s ) {
    311 //              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     311//              if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    312312//              fmt( os, "%ls", s );
    313313//              return os;
     
    316316// #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
    317317//      ostype & ?|?( ostype & os, const char32_t * s ) {
    318 //              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     318//              if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    319319//              fmt( os, "%ls", s );
    320320//              return os;
     
    323323
    324324//      ostype & ?|?( ostype & os, const wchar_t * s ) {
    325 //              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     325//              if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    326326//              fmt( os, "%ls", s );
    327327//              return os;
     
    329329
    330330        ostype & ?|?( ostype & os, const void * p ) {
    331                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     331                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    332332                fmt( os, "%p", p );
    333333                return os;
     
    343343        void ?|?( ostype & os, ostype & (* manip)( ostype & ) ) {
    344344                manip( os );
    345                 if ( $getPrt( os ) ) ends( os );                                // something printed ?
    346                 $setPrt( os, false );                                                   // turn off
     345                if ( getPrt$( os ) ) ends( os );                                // something printed ?
     346                setPrt$( os, false );                                                   // turn off
    347347        } // ?|?
    348348
     
    357357        ostype & nl( ostype & os ) {
    358358                (ostype &)(os | '\n');
    359                 $setPrt( os, false );                                                   // turn off
    360                 $setNL( os, true );
     359                setPrt$( os, false );                                                   // turn off
     360                setNL$( os, true );
    361361                flush( os );
    362362                return sepOff( os );                                                    // prepare for next line
     
    364364
    365365        ostype & nonl( ostype & os ) {
    366                 $setPrt( os, false );                                                   // turn off
     366                setPrt$( os, false );                                                   // turn off
    367367                return os;
    368368        } // nonl
     
    408408        ostype & ?|?( ostype & os, T arg, Params rest ) {
    409409                (ostype &)(os | arg);                                                   // print first argument
    410                 $sepSetCur( os, sepGetTuple( os ) );                    // switch to tuple separator
     410                sepSetCur$( os, sepGetTuple( os ) );                    // switch to tuple separator
    411411                (ostype &)(os | rest);                                                  // print remaining arguments
    412                 $sepSetCur( os, sepGet( os ) );                                 // switch to regular separator
     412                sepSetCur$( os, sepGet( os ) );                                 // switch to regular separator
    413413                return os;
    414414        } // ?|?
     
    416416                // (ostype &)(?|?( os, arg, rest )); ends( os );
    417417                (ostype &)(os | arg);                                                   // print first argument
    418                 $sepSetCur( os, sepGetTuple( os ) );                    // switch to tuple separator
     418                sepSetCur$( os, sepGetTuple( os ) );                    // switch to tuple separator
    419419                (ostype &)(os | rest);                                                  // print remaining arguments
    420                 $sepSetCur( os, sepGet( os ) );                                 // switch to regular separator
     420                sepSetCur$( os, sepGet( os ) );                                 // switch to regular separator
    421421                ends( os );
    422422        } // ?|?
     
    447447forall( ostype & | ostream( ostype ) ) { \
    448448        ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
    449                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
     449                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) ); \
    450450\
    451451                if ( f.base == 'b' || f.base == 'B' ) {                 /* bespoke binary format */ \
     
    691691                int bufbeg = 0, i, len; \
    692692\
    693                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
     693                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) ); \
    694694                char fmtstr[sizeof(DFMTP) + 8];                                 /* sizeof includes '\0' */ \
    695695                if ( ! f.flags.pc ) memcpy( &fmtstr, DFMTNP, sizeof(DFMTNP) ); \
     
    734734                } // if
    735735
    736                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     736                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    737737
    738738                #define CFMTNP "% * "
     
    772772                } // if
    773773
    774                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     774                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    775775
    776776                #define SFMTNP "% * "
  • libcfa/src/iostream.hfa

    r59f3f61 r6c5d92f  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Apr 13 13:05:11 2021
    13 // Update Count     : 384
     12// Last Modified On : Tue Apr 20 19:09:44 2021
     13// Update Count     : 385
    1414//
    1515
     
    2424trait ostream( ostype & ) {
    2525        // private
    26         bool $sepPrt( ostype & );                                                       // get separator state (on/off)
    27         void $sepReset( ostype & );                                                     // set separator state to default state
    28         void $sepReset( ostype &, bool );                                       // set separator and default state
    29         const char * $sepGetCur( ostype & );                            // get current separator string
    30         void $sepSetCur( ostype &, const char [] );                     // set current separator string
    31         bool $getNL( ostype & );                                                        // check newline
    32         void $setNL( ostype &, bool );                                          // saw newline
    33         bool $getANL( ostype & );                                                       // get auto newline (on/off)
    34         bool $getPrt( ostype & );                                                       // get fmt called in output cascade
    35         void $setPrt( ostype &, bool );                                         // set fmt called in output cascade
     26        bool sepPrt$( ostype & );                                                       // get separator state (on/off)
     27        void sepReset$( ostype & );                                                     // set separator state to default state
     28        void sepReset$( ostype &, bool );                                       // set separator and default state
     29        const char * sepGetCur$( ostype & );                            // get current separator string
     30        void sepSetCur$( ostype &, const char [] );                     // set current separator string
     31        bool getNL$( ostype & );                                                        // check newline
     32        void setNL$( ostype &, bool );                                          // saw newline
     33        bool getANL$( ostype & );                                                       // get auto newline (on/off)
     34        bool getPrt$( ostype & );                                                       // get fmt called in output cascade
     35        void setPrt$( ostype &, bool );                                         // set fmt called in output cascade
    3636        // public
    3737        void sepOn( ostype & );                                                         // turn separator state on
  • libcfa/src/stdlib.hfa

    r59f3f61 r6c5d92f  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jan 21 22:02:13 2021
    13 // Update Count     : 574
     12// Last Modified On : Tue Apr 20 21:20:03 2021
     13// Update Count     : 575
    1414//
    1515
     
    4444
    4545// Macro because of returns
    46 #define $ARRAY_ALLOC( allocation, alignment, dim ) \
     46#define ARRAY_ALLOC$( allocation, alignment, dim ) \
    4747        if ( _Alignof(T) <= libAlign() ) return (T *)(void *)allocation( dim, (size_t)sizeof(T) ); /* C allocation */ \
    4848        else return (T *)alignment( _Alignof(T), dim, sizeof(T) )
     
    5757
    5858        T * aalloc( size_t dim ) {
    59                 $ARRAY_ALLOC( aalloc, amemalign, dim );
     59                ARRAY_ALLOC$( aalloc, amemalign, dim );
    6060        } // aalloc
    6161
    6262        T * calloc( size_t dim ) {
    63                 $ARRAY_ALLOC( calloc, cmemalign, dim );
     63                ARRAY_ALLOC$( calloc, cmemalign, dim );
    6464        } // calloc
    6565
     
    119119                S_fill(T) ?`fill( T    a[], size_t nmemb )      { S_fill(T) ret = {'a', nmemb}; ret.fill.a = a; return ret; }
    120120
    121         3. Replace the $alloc_internal function which is outside ttype forall-block with following function:
    122                 T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill) {
     121        3. Replace the alloc_internal$ function which is outside ttype forall-block with following function:
     122                T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill) {
    123123                        T * ptr = NULL;
    124124                        size_t size = sizeof(T);
     
    145145
    146146                        return ptr;
    147                 } // $alloc_internal
     147                } // alloc_internal$
    148148*/
    149149
     
    175175        S_realloc(T)    ?`realloc ( T * a )                             { return (S_realloc(T)){a}; }
    176176
    177         T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill ) {
     177        T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill ) {
    178178                T * ptr = NULL;
    179179                size_t size = sizeof(T);
     
    206206
    207207                return ptr;
    208         } // $alloc_internal
    209 
    210         forall( TT... | { T * $alloc_internal( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
    211 
    212                 T * $alloc_internal( void *       , T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest) {
    213                 return $alloc_internal( Resize, (T*)0p, Align, Dim, Fill, rest);
    214                 }
    215 
    216                 T * $alloc_internal( void * Resize, T *        , size_t Align, size_t Dim, S_fill(T) Fill, S_realloc(T) Realloc, TT rest) {
    217                 return $alloc_internal( (void*)0p, Realloc, Align, Dim, Fill, rest);
    218                 }
    219 
    220                 T * $alloc_internal( void * Resize, T * Realloc, size_t      , size_t Dim, S_fill(T) Fill, T_align Align, TT rest) {
    221                 return $alloc_internal( Resize, Realloc, Align, Dim, Fill, rest);
    222                 }
    223 
    224                 T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T)     , S_fill(T) Fill, TT rest) {
    225                 return $alloc_internal( Resize, Realloc, Align, Dim, Fill, rest);
     208        } // alloc_internal$
     209
     210        forall( TT... | { T * alloc_internal$( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
     211
     212                T * alloc_internal$( void *       , T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest) {
     213                return alloc_internal$( Resize, (T*)0p, Align, Dim, Fill, rest);
     214                }
     215
     216                T * alloc_internal$( void * Resize, T *        , size_t Align, size_t Dim, S_fill(T) Fill, S_realloc(T) Realloc, TT rest) {
     217                return alloc_internal$( (void*)0p, Realloc, Align, Dim, Fill, rest);
     218                }
     219
     220                T * alloc_internal$( void * Resize, T * Realloc, size_t      , size_t Dim, S_fill(T) Fill, T_align Align, TT rest) {
     221                return alloc_internal$( Resize, Realloc, Align, Dim, Fill, rest);
     222                }
     223
     224                T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T)     , S_fill(T) Fill, TT rest) {
     225                return alloc_internal$( Resize, Realloc, Align, Dim, Fill, rest);
    226226                }
    227227
    228228            T * alloc( TT all ) {
    229                 return $alloc_internal( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), (size_t)1, (S_fill(T)){'0'}, all);
     229                return alloc_internal$( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), (size_t)1, (S_fill(T)){'0'}, all);
    230230            }
    231231
    232232            T * alloc( size_t dim, TT all ) {
    233                 return $alloc_internal( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), dim, (S_fill(T)){'0'}, all);
     233                return alloc_internal$( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), dim, (S_fill(T)){'0'}, all);
    234234            }
    235235
Note: See TracChangeset for help on using the changeset viewer.