Changeset 93c2e0a


Ignore:
Timestamp:
Aug 11, 2018, 5:04:35 PM (3 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer
Children:
e765794
Parents:
a37133c
Message:

change _Bool to bool

Location:
src/libcfa
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • src/libcfa/bits/locks.h

    ra37133c r93c2e0a  
    1010// Created On       : Tue Oct 31 15:14:38 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 30 18:18:13 2018
    13 // Update Count     : 9
     12// Last Modified On : Sat Aug 11 15:42:24 2018
     13// Update Count     : 10
    1414//
    1515
     
    5050        struct {
    5151                // Align lock on 128-bit boundary
    52                 __ALIGN__ volatile _Bool lock;
     52                __ALIGN__ volatile bool lock;
    5353        };
    5454        #ifdef __CFA_DEBUG__
     
    7979
    8080        // Lock the spinlock, return false if already acquired
    81         static inline _Bool try_lock  ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
    82                 _Bool result = (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0);
     81        static inline bool try_lock  ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
     82                bool result = (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0);
    8383                if( result ) {
    8484                        disable_interrupts();
  • src/libcfa/fstream

    ra37133c r93c2e0a  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jun  5 10:20:25 2018
    13 // Update Count     : 131
     12// Last Modified On : Sat Aug 11 13:54:27 2018
     13// Update Count     : 132
    1414//
    1515
     
    2121struct ofstream {
    2222        void * file;
    23         _Bool sepDefault;
    24         _Bool sepOnOff;
    25         _Bool sawNL;
     23        bool sepDefault;
     24        bool sepOnOff;
     25        bool sawNL;
    2626        const char * sepCur;
    2727        char separator[sepSize];
     
    3030
    3131// private
    32 _Bool sepPrt( ofstream & );
     32bool sepPrt( ofstream & );
    3333void sepReset( ofstream & );
    34 void sepReset( ofstream &, _Bool );
     34void sepReset( ofstream &, bool );
    3535const char * sepGetCur( ofstream & );
    3636void sepSetCur( ofstream &, const char * );
    37 _Bool getNL( ofstream & );
    38 void setNL( ofstream &, _Bool );
     37bool getNL( ofstream & );
     38void setNL( ofstream &, bool );
    3939
    4040// public
    4141void sepOn( ofstream & );
    4242void sepOff( ofstream & );
    43 _Bool sepDisable( ofstream & );
    44 _Bool sepEnable( ofstream & );
     43bool sepDisable( ofstream & );
     44bool sepEnable( ofstream & );
    4545
    4646const char * sepGet( ofstream & );
  • src/libcfa/fstream.c

    ra37133c r93c2e0a  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jun  5 17:02:56 2018
    13 // Update Count     : 281
     12// Last Modified On : Fri Aug 10 18:19:40 2018
     13// Update Count     : 284
    1414//
    1515
     
    2727#define IO_MSG "I/O error: "
    2828
    29 void ?{}( ofstream & os, void * file, _Bool sepDefault, _Bool sepOnOff, const char * separator, const char * tupleSeparator ) {
     29void ?{}( ofstream & os, void * file, bool sepDefault, bool sepOnOff, const char * separator, const char * tupleSeparator ) {
    3030        os.file = file;
    3131        os.sepDefault = sepDefault;
     
    3737
    3838// private
    39 _Bool sepPrt( ofstream & os ) { setNL( os, false ); return os.sepOnOff; }
     39bool sepPrt( ofstream & os ) { setNL( os, false ); return os.sepOnOff; }
    4040void sepReset( ofstream & os ) { os.sepOnOff = os.sepDefault; }
    41 void sepReset( ofstream & os, _Bool reset ) { os.sepDefault = reset; os.sepOnOff = os.sepDefault; }
     41void sepReset( ofstream & os, bool reset ) { os.sepDefault = reset; os.sepOnOff = os.sepDefault; }
    4242const char * sepGetCur( ofstream & os ) { return os.sepCur; }
    4343void sepSetCur( ofstream & os, const char * sepCur ) { os.sepCur = sepCur; }
    44 _Bool getNL( ofstream & os ) { return os.sawNL; }
    45 void setNL( ofstream & os, _Bool state ) { os.sawNL = state; }
     44bool getNL( ofstream & os ) { return os.sawNL; }
     45void setNL( ofstream & os, bool state ) { os.sawNL = state; }
    4646
    4747// public
     
    5858void sepOff( ofstream & os ) { os.sepOnOff = false; }
    5959
    60 _Bool sepDisable( ofstream & os ) {
    61         _Bool temp = os.sepDefault;
     60bool sepDisable( ofstream & os ) {
     61        bool temp = os.sepDefault;
    6262        os.sepDefault = false;
    6363        sepReset( os );
     
    6565} // sepDisable
    6666
    67 _Bool sepEnable( ofstream & os ) {
    68         _Bool temp = os.sepDefault;
     67bool sepEnable( ofstream & os ) {
     68        bool temp = os.sepDefault;
    6969        os.sepDefault = true;
    7070        if ( os.sepOnOff ) sepReset( os );                                      // start of line ?
     
    9696void open( ofstream & os, const char * name, const char * mode ) {
    9797        FILE *file = fopen( name, mode );
    98         // if ( file == 0 ) {                                                                   // do not change unless successful
    99         //      fprintf( stderr, IO_MSG "open output file \"%s\", ", name );
    100         //      perror( 0 );
    101         //      exit( EXIT_FAILURE );
    102         // } // if
     98        #ifdef __CFA_DEBUG__
     99        if ( file == 0 ) {
     100                fprintf( stderr, IO_MSG "open output file \"%s\", ", name );
     101                perror( 0 );
     102                exit( EXIT_FAILURE );
     103        } // if
     104        #endif // __CFA_DEBUG__
    103105        (os){ file, true, false, " ", ", " };
    104106} // open
     
    178180void open( ifstream & is, const char * name, const char * mode ) {
    179181        FILE *file = fopen( name, mode );
    180         // if ( file == 0 ) {                                                                   // do not change unless successful
    181         //      fprintf( stderr, IO_MSG "open input file \"%s\", ", name );
    182         //      perror( 0 );
    183         //      exit( EXIT_FAILURE );
    184         // } // if
     182        #ifdef __CFA_DEBUG__
     183        if ( file == 0 ) {
     184                fprintf( stderr, IO_MSG "open input file \"%s\", ", name );
     185                perror( 0 );
     186                exit( EXIT_FAILURE );
     187        } // if
     188        #endif // __CFA_DEBUG__
    185189        is.file = file;
    186190} // open
  • src/libcfa/heap.c

    ra37133c r93c2e0a  
    1010// Created On       : Tue Dec 19 21:58:35 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 31 18:08:50 2018
    13 // Update Count     : 470
     12// Last Modified On : Sat Aug 11 08:22:16 2018
     13// Update Count     : 495
    1414//
    1515
     
    7575
    7676
    77 static _Bool traceHeap = false;
    78 
    79 inline _Bool traceHeap() {
     77static bool traceHeap = false;
     78
     79inline bool traceHeap() {
    8080        return traceHeap;
    8181} // traceHeap
    8282
    83 _Bool traceHeapOn() {
    84         _Bool temp = traceHeap;
     83bool traceHeapOn() {
     84        bool temp = traceHeap;
    8585        traceHeap = true;
    8686        return temp;
    8787} // traceHeapOn
    8888
    89 _Bool traceHeapOff() {
    90         _Bool temp = traceHeap;
     89bool traceHeapOff() {
     90        bool temp = traceHeap;
    9191        traceHeap = false;
    9292        return temp;
     
    9494
    9595
    96 static _Bool checkFree = false;
    97 
    98 inline _Bool checkFree() {
     96static bool checkFree = false;
     97
     98inline bool checkFree() {
    9999        return checkFree;
    100100} // checkFree
    101101
    102 _Bool checkFreeOn() {
    103         _Bool temp = checkFree;
     102bool checkFreeOn() {
     103        bool temp = checkFree;
    104104        checkFree = true;
    105105        return temp;
    106106} // checkFreeOn
    107107
    108 _Bool checkFreeOff() {
    109         _Bool temp = checkFree;
     108bool checkFreeOff() {
     109        bool temp = checkFree;
    110110        checkFree = false;
    111111        return temp;
     
    113113
    114114
    115 // static _Bool traceHeapTerm = false;
    116 
    117 // inline _Bool traceHeapTerm() {
     115// static bool traceHeapTerm = false;
     116
     117// inline bool traceHeapTerm() {
    118118//      return traceHeapTerm;
    119119// } // traceHeapTerm
    120120
    121 // _Bool traceHeapTermOn() {
    122 //      _Bool temp = traceHeapTerm;
     121// bool traceHeapTermOn() {
     122//      bool temp = traceHeapTerm;
    123123//      traceHeapTerm = true;
    124124//      return temp;
    125125// } // traceHeapTermOn
    126126
    127 // _Bool traceHeapTermOff() {
    128 //      _Bool temp = traceHeapTerm;
     127// bool traceHeapTermOff() {
     128//      bool temp = traceHeapTerm;
    129129//      traceHeapTerm = false;
    130130//      return temp;
     
    133133
    134134#ifdef __CFA_DEBUG__
    135 static unsigned int allocfree;                                                  // running total of allocations minus frees
    136 static unsigned int appStart;                                                   // storage allocation when application starts
     135static unsigned int allocFree;                                                  // running total of allocations minus frees
    137136
    138137static void checkUnfreed() {
    139         unsigned int total = allocfree - appStart;
    140     if ( total != 0 ) {
     138    if ( allocFree != 0 ) {
    141139                // DO NOT USE STREAMS AS THEY MAY BE UNAVAILABLE AT THIS POINT.
    142140                // char helpText[512];
    143                 // int len = snprintf( helpText, 512, "CFA warning (UNIX pid:%ld) : program terminating with %u(0x%x) bytes of storage allocated but not freed.\n"
     141                // int len = snprintf( helpText, sizeof(helpText), "CFA warning (UNIX pid:%ld) : program terminating with %u(0x%x) bytes of storage allocated but not freed.\n"
    144142                //                                      "Possible cause is unfreed storage allocated by the program or system/library routines called from the program.\n",
    145                 //                                      (long int)getpid(), total, total ); // always print the UNIX pid
     143                //                                      (long int)getpid(), allocFree, allocFree ); // always print the UNIX pid
    146144                // __cfaabi_dbg_bits_write( helpText, len );
    147145    } // if
     
    150148extern "C" {
    151149void heapAppStart() {                                                                   // called by __cfaabi_appready_startup
    152         appStart = allocfree;
     150        allocFree = 0;
    153151} // heapAppStart
    154152
    155153void heapAppStop() {                                                                    // called by __cfaabi_appready_startdown
     154        fclose( stdin ); fclose( stdout );
    156155        checkUnfreed();
    157156} // heapAppStop
     
    191190                                                #endif // LOCKFREE
    192191                                        };
    193                                 } real;
     192                                } real; // RealHeader
    194193                                struct FakeHeader {
    195194                                        #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
     
    202201                                        uint32_t alignment;                                     // low-order bits of home/blockSize used for tricks
    203202                                        #endif // __ORDER_BIG_ENDIAN__
    204                                 } fake;
    205                         } kind;
     203                                } fake; // FakeHeader
     204                        } kind; // Kind
    206205            } header; // Header
    207206            char pad[ALIGN - sizeof( Header )];
     
    264263
    265264#ifdef __CFA_DEBUG__
    266 static _Bool heapBoot = 0;                                                              // detect recursion during boot
     265static bool heapBoot = 0;                                                               // detect recursion during boot
    267266#endif // __CFA_DEBUG__
    268267static HeapManager heapManager __attribute__(( aligned (128) )) @= {}; // size of cache line to prevent false sharing
    269268
    270269
    271 static inline _Bool setMmapStart( size_t value ) {
     270static inline bool setMmapStart( size_t value ) {
    272271    if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return true;
    273272    mmapStart = value;                                                                  // set global
     
    363362static void printStats() {
    364363    char helpText[512];
    365         __cfaabi_dbg_bits_print_buffer( helpText, 512,
     364        __cfaabi_dbg_bits_print_buffer( helpText, sizeof(helpText),
    366365                        "\nHeap statistics:\n"
    367366                        "  malloc: calls %u / storage %llu\n"
     
    389388static int printStatsXML( FILE * stream ) {
    390389    char helpText[512];
    391     int len = snprintf( helpText, 512,
     390    int len = snprintf( helpText, sizeof(helpText),
    392391                                                "<malloc version=\"1\">\n"
    393392                                                "<heap nr=\"0\">\n"
     
    433432
    434433
    435 static inline _Bool setHeapExpand( size_t value ) {
     434static inline bool setHeapExpand( size_t value ) {
    436435    if ( heapExpand < pageSize ) return true;
    437436    heapExpand = value;
     
    440439
    441440
    442 static inline void checkHeader( _Bool check, const char * name, void * addr ) {
     441static inline void checkHeader( bool check, const char * name, void * addr ) {
    443442    if ( unlikely( check ) ) {                                                  // bad address ?
    444443                abort( "Attempt to %s storage %p with address outside the heap.\n"
     
    463462#define headerAddr( addr ) ((HeapManager.Storage.Header *)( (char *)addr - sizeof(HeapManager.Storage) ))
    464463
    465 static inline _Bool headers( const char * name, void * addr, HeapManager.Storage.Header *& header, HeapManager.FreeHeader *& freeElem, size_t & size, size_t & alignment ) with ( heapManager ) {
     464static inline bool headers( const char * name, void * addr, HeapManager.Storage.Header *& header, HeapManager.FreeHeader *& freeElem, size_t & size, size_t & alignment ) with ( heapManager ) {
    466465    header = headerAddr( addr );
    467466
     
    589588        #ifdef __CFA_DEBUG__
    590589    assert( ((uintptr_t)area & (libAlign() - 1)) == 0 ); // minimum alignment ?
    591     __atomic_add_fetch( &allocfree, tsize, __ATOMIC_SEQ_CST );
     590    __atomic_add_fetch( &allocFree, tsize, __ATOMIC_SEQ_CST );
    592591        if ( traceHeap() ) {
    593592                enum { BufferSize = 64 };
     
    646645
    647646        #ifdef __CFA_DEBUG__
    648     __atomic_add_fetch( &allocfree, -size, __ATOMIC_SEQ_CST );
     647    __atomic_add_fetch( &allocFree, -size, __ATOMIC_SEQ_CST );
    649648    if ( traceHeap() ) {
    650                 enum { BufferSize = 64 };
    651                 char helpText[BufferSize];
    652                 int len = snprintf( helpText, BufferSize, "Free( %p ) size:%zu\n", addr, size );
     649                char helpText[64];
     650                int len = snprintf( helpText, sizeof(helpText), "Free( %p ) size:%zu\n", addr, size );
    653651                __cfaabi_dbg_bits_write( helpText, len );
    654652    } // if
     
    758756                HeapManager.FreeHeader * freeElem;
    759757                size_t asize, alignment;
    760                 _Bool mapped __attribute__(( unused )) = headers( "calloc", area, header, freeElem, asize, alignment );
     758                bool mapped __attribute__(( unused )) = headers( "calloc", area, header, freeElem, asize, alignment );
    761759                #ifndef __CFA_DEBUG__
    762760                // Mapped storage is zero filled, but in debug mode mapped memory is scrubbed in doMalloc, so it has to be reset to zero.
     
    781779                HeapManager.FreeHeader * freeElem;
    782780                size_t asize;
    783                 _Bool mapped __attribute__(( unused )) = headers( "cmemalign", area, header, freeElem, asize, alignment );
     781                bool mapped __attribute__(( unused )) = headers( "cmemalign", area, header, freeElem, asize, alignment );
    784782                #ifndef __CFA_DEBUG__
    785783                // Mapped storage is zero filled, but in debug mode mapped memory is scrubbed in doMalloc, so it has to be reset to zero.
     
    826824                if ( unlikely( header->kind.real.blockSize & 2 ) ) { // previous request zero fill (calloc/cmemalign) ?
    827825                        assert( (header->kind.real.blockSize & 1) == 0 );
    828                         _Bool mapped __attribute__(( unused )) = headers( "realloc", area, header, freeElem, asize, alignment );
     826                        bool mapped __attribute__(( unused )) = headers( "realloc", area, header, freeElem, asize, alignment );
    829827                        #ifndef __CFA_DEBUG__
    830828                        // Mapped storage is zero filled, but in debug mode mapped memory is scrubbed in doMalloc, so it has to be reset to zero.
     
    889887    } // free
    890888
     889
    891890    int mallopt( int option, int value ) {
    892891                choose( option ) {
     
    929928
    930929
    931     _Bool malloc_zero_fill( void * addr ) {
     930    bool malloc_zero_fill( void * addr ) {
    932931                if ( unlikely( addr == 0 ) ) return false;              // null allocation is not zero fill
    933932                HeapManager.Storage.Header * header = (HeapManager.Storage.Header *)( (char *)addr - sizeof(HeapManager.Storage) );
  • src/libcfa/iostream

    ra37133c r93c2e0a  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jul  1 12:12:22 2018
    13 // Update Count     : 155
     12// Last Modified On : Sat Aug 11 08:22:49 2018
     13// Update Count     : 156
    1414//
    1515
     
    2020trait ostream( dtype ostype ) {
    2121        // private
    22         _Bool sepPrt( ostype & );                                                       // return separator state (on/off)
     22        bool sepPrt( ostype & );                                                        // return separator state (on/off)
    2323        void sepReset( ostype & );                                                      // set separator state to default state
    24         void sepReset( ostype &, _Bool );                                       // set separator and default state
     24        void sepReset( ostype &, bool );                                        // set separator and default state
    2525        const char * sepGetCur( ostype & );                                     // get current separator string
    2626        void sepSetCur( ostype &, const char * );                       // set current separator string
    27         _Bool getNL( ostype & );                                                        // check newline
    28         void setNL( ostype &, _Bool );                                          // saw newline
     27        bool getNL( ostype & );                                                 // check newline
     28        void setNL( ostype &, bool );                                           // saw newline
    2929        // public
    3030        void sepOn( ostype & );                                                         // turn separator state on
    3131        void sepOff( ostype & );                                                        // turn separator state off
    32         _Bool sepDisable( ostype & );                                           // set default state to off, and return previous state
    33         _Bool sepEnable( ostype & );                                            // set default state to on, and return previous state
     32        bool sepDisable( ostype & );                                            // set default state to off, and return previous state
     33        bool sepEnable( ostype & );                                             // set default state to on, and return previous state
    3434
    3535        const char * sepGet( ostype & );                                        // get separator string
     
    5757
    5858forall( dtype ostype | ostream( ostype ) ) {
    59         ostype & ?|?( ostype &, _Bool );
     59        ostype & ?|?( ostype &, bool );
    6060
    6161        ostype & ?|?( ostype &, char );
     
    127127
    128128forall( dtype istype | istream( istype ) ) {
    129         istype & ?|?( istype &, _Bool & );
     129        istype & ?|?( istype &, bool & );
    130130
    131131        istype & ?|?( istype &, char & );
  • src/libcfa/iostream.c

    ra37133c r93c2e0a  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jun  2 08:24:56 2018
    13 // Update Count     : 471
     12// Last Modified On : Sat Aug 11 13:56:43 2018
     13// Update Count     : 473
    1414//
    1515
     
    2727
    2828forall( dtype ostype | ostream( ostype ) ) {
    29         ostype & ?|?( ostype & os, _Bool b ) {
     29        ostype & ?|?( ostype & os, bool b ) {
    3030                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    3131                fmt( os, "%s", b ? "true" : "false" );
     
    275275
    276276forall( dtype istype | istream( istype ) ) {
    277         istype & ?|?( istype & is, _Bool & b ) {
     277        istype & ?|?( istype & is, bool & b ) {
    278278                char val[6];
    279279                fmt( is, "%5s", val );
     
    281281                else if ( strcmp( val, "false" ) == 0 ) b = false;
    282282                else {
    283                         fprintf( stderr, "invalid _Bool constant\n" );
     283                        fprintf( stderr, "invalid Boolean constant\n" );
    284284                        abort();
    285285                } // if
  • src/libcfa/stdhdr/malloc.h

    ra37133c r93c2e0a  
    1010// Created On       : Thu Jul 20 15:58:16 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 31 10:01:10 2018
    13 // Update Count     : 9
     12// Last Modified On : Sat Aug 11 09:06:31 2018
     13// Update Count     : 10
    1414//
    1515
     
    1818size_t default_heap_expansion();
    1919
    20 _Bool traceHeap();
    21 _Bool traceHeapOn();
    22 _Bool traceHeapOff();
     20bool traceHeap();
     21bool traceHeapOn();
     22bool traceHeapOff();
    2323
    24 _Bool traceHeapTerm();
    25 _Bool traceHeapTermOn();
    26 _Bool traceHeapTermOff();
     24bool traceHeapTerm();
     25bool traceHeapTermOn();
     26bool traceHeapTermOff();
    2727
    28 _Bool checkFree();
    29 _Bool checkFreeOn();
    30 _Bool checkFreeOff();
     28bool checkFree();
     29bool checkFreeOn();
     30bool checkFreeOff();
    3131
    3232extern "C" {
    3333size_t malloc_alignment( void * );
    34 _Bool malloc_zero_fill( void * );
     34bool malloc_zero_fill( void * );
    3535int malloc_stats_fd( int fd );
    3636void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize );
  • src/libcfa/time

    ra37133c r93c2e0a  
    1010// Created On       : Wed Mar 14 23:18:57 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jul  2 21:28:38 2018
    13 // Update Count     : 641
     12// Last Modified On : Sat Aug 11 13:55:33 2018
     13// Update Count     : 642
    1414//
    1515
     
    5252        Duration ?%=?( Duration & lhs, Duration rhs ) { lhs = lhs % rhs; return lhs; }
    5353
    54         _Bool ?==?( Duration lhs, Duration rhs ) { return lhs.tv == rhs.tv; }
    55         _Bool ?!=?( Duration lhs, Duration rhs ) { return lhs.tv != rhs.tv; }
    56         _Bool ?<? ( Duration lhs, Duration rhs ) { return lhs.tv <  rhs.tv; }
    57         _Bool ?<=?( Duration lhs, Duration rhs ) { return lhs.tv <= rhs.tv; }
    58         _Bool ?>? ( Duration lhs, Duration rhs ) { return lhs.tv >  rhs.tv; }
    59         _Bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tv >= rhs.tv; }
    60 
    61         _Bool ?==?( Duration lhs, zero_t ) { return lhs.tv == 0; }
    62         _Bool ?!=?( Duration lhs, zero_t ) { return lhs.tv != 0; }
    63         _Bool ?<? ( Duration lhs, zero_t ) { return lhs.tv <  0; }
    64         _Bool ?<=?( Duration lhs, zero_t ) { return lhs.tv <= 0; }
    65         _Bool ?>? ( Duration lhs, zero_t ) { return lhs.tv >  0; }
    66         _Bool ?>=?( Duration lhs, zero_t ) { return lhs.tv >= 0; }
     54        bool ?==?( Duration lhs, Duration rhs ) { return lhs.tv == rhs.tv; }
     55        bool ?!=?( Duration lhs, Duration rhs ) { return lhs.tv != rhs.tv; }
     56        bool ?<? ( Duration lhs, Duration rhs ) { return lhs.tv <  rhs.tv; }
     57        bool ?<=?( Duration lhs, Duration rhs ) { return lhs.tv <= rhs.tv; }
     58        bool ?>? ( Duration lhs, Duration rhs ) { return lhs.tv >  rhs.tv; }
     59        bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tv >= rhs.tv; }
     60
     61        bool ?==?( Duration lhs, zero_t ) { return lhs.tv == 0; }
     62        bool ?!=?( Duration lhs, zero_t ) { return lhs.tv != 0; }
     63        bool ?<? ( Duration lhs, zero_t ) { return lhs.tv <  0; }
     64        bool ?<=?( Duration lhs, zero_t ) { return lhs.tv <= 0; }
     65        bool ?>? ( Duration lhs, zero_t ) { return lhs.tv >  0; }
     66        bool ?>=?( Duration lhs, zero_t ) { return lhs.tv >= 0; }
    6767
    6868        Duration abs( Duration rhs ) { return rhs.tv >= 0 ? rhs : -rhs; }
     
    106106        timeval ?+?( timeval & lhs, timeval rhs ) { return (timeval)@{ lhs.tv_sec + rhs.tv_sec, lhs.tv_usec + rhs.tv_usec }; }
    107107        timeval ?-?( timeval & lhs, timeval rhs ) { return (timeval)@{ lhs.tv_sec - rhs.tv_sec, lhs.tv_usec - rhs.tv_usec }; }
    108         _Bool ?==?( timeval lhs, timeval rhs ) { return lhs.tv_sec == rhs.tv_sec && lhs.tv_usec == rhs.tv_usec; }
    109         _Bool ?!=?( timeval lhs, timeval rhs ) { return lhs.tv_sec != rhs.tv_sec || lhs.tv_usec != rhs.tv_usec; }
     108        bool ?==?( timeval lhs, timeval rhs ) { return lhs.tv_sec == rhs.tv_sec && lhs.tv_usec == rhs.tv_usec; }
     109        bool ?!=?( timeval lhs, timeval rhs ) { return lhs.tv_sec != rhs.tv_sec || lhs.tv_usec != rhs.tv_usec; }
    110110} // distribution
    111111
     
    121121        timespec ?+?( timespec & lhs, timespec rhs ) { return (timespec)@{ lhs.tv_sec + rhs.tv_sec, lhs.tv_nsec + rhs.tv_nsec }; }
    122122        timespec ?-?( timespec & lhs, timespec rhs ) { return (timespec)@{ lhs.tv_sec - rhs.tv_sec, lhs.tv_nsec - rhs.tv_nsec }; }
    123         _Bool ?==?( timespec lhs, timespec rhs ) { return lhs.tv_sec == rhs.tv_sec && lhs.tv_nsec == rhs.tv_nsec; }
    124         _Bool ?!=?( timespec lhs, timespec rhs ) { return lhs.tv_sec != rhs.tv_sec || lhs.tv_nsec != rhs.tv_nsec; }
     123        bool ?==?( timespec lhs, timespec rhs ) { return lhs.tv_sec == rhs.tv_sec && lhs.tv_nsec == rhs.tv_nsec; }
     124        bool ?!=?( timespec lhs, timespec rhs ) { return lhs.tv_sec != rhs.tv_sec || lhs.tv_nsec != rhs.tv_nsec; }
    125125} // distribution
    126126
     
    166166        Time ?-?( Time lhs, Duration rhs ) { return (Time)@{ lhs.tv - rhs.tv }; }
    167167        Time ?-=?( Time & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
    168         _Bool ?==?( Time lhs, Time rhs ) { return lhs.tv == rhs.tv; }
    169         _Bool ?!=?( Time lhs, Time rhs ) { return lhs.tv != rhs.tv; }
    170         _Bool ?<?( Time lhs, Time rhs ) { return lhs.tv < rhs.tv; }
    171         _Bool ?<=?( Time lhs, Time rhs ) { return lhs.tv <= rhs.tv; }
    172         _Bool ?>?( Time lhs, Time rhs ) { return lhs.tv > rhs.tv; }
    173         _Bool ?>=?( Time lhs, Time rhs ) { return lhs.tv >= rhs.tv; }
     168        bool ?==?( Time lhs, Time rhs ) { return lhs.tv == rhs.tv; }
     169        bool ?!=?( Time lhs, Time rhs ) { return lhs.tv != rhs.tv; }
     170        bool ?<?( Time lhs, Time rhs ) { return lhs.tv < rhs.tv; }
     171        bool ?<=?( Time lhs, Time rhs ) { return lhs.tv <= rhs.tv; }
     172        bool ?>?( Time lhs, Time rhs ) { return lhs.tv > rhs.tv; }
     173        bool ?>=?( Time lhs, Time rhs ) { return lhs.tv >= rhs.tv; }
    174174} // distribution
    175175
Note: See TracChangeset for help on using the changeset viewer.