Changeset 1dec8f3 for libcfa/src


Ignore:
Timestamp:
Sep 22, 2025, 2:33:42 PM (5 months ago)
Author:
Michael Brooks <mlbrooks@…>
Branches:
master, stuck-waitfor-destruct
Children:
bb5b866
Parents:
7ca6bf1 (diff), 295ed2d1 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge remote-tracking branch 'refs/remotes/origin/master'

Location:
libcfa/src
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/collections/string.cfa

    r7ca6bf1 r1dec8f3  
    1010// Created On       : Fri Sep 03 11:00:00 2021
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Apr 13 07:58:55 2025
    13 // Update Count     : 390
     12// Last Modified On : Mon Sep 15 10:26:35 2025
     13// Update Count     : 394
    1414//
    1515
    … …  
    9797}
    9898
    99 string str( ssize_t rhs ) {
    100         string s = rhs;
    101         return s;
    102 }
    103 
    104 string str( size_t rhs ) {
    105         string s = rhs;
    106         return s;
    107 }
    108 
    109 string str( double rhs ) {
    110         string s = rhs;
    111         return s;
    112 }
    113 
    114 string str( long double rhs ) {
    115         string s = rhs;
    116         return s;
    117 }
    118 
    119 string str( double _Complex rhs ) {
    120         string s = rhs;
    121         return s;
    122 }
    123 
    124 string str( long double _Complex rhs ) {
    125         string s = rhs;
    126         return s;
    127 }
    128 
    12999void ^?{}( string & s ) {
    130100        ^(*s.inner){};
    … …  
    204174
    205175////////////////////////////////////////////////////////
    206 // Getter
     176// C-style
     177
     178// safe conversion from string to char *
     179char * strncpy( char * dst, string & src, size_t n ) {
     180        size_t l = min( n - 1, len( src ) );                            // ensure null terminated
     181        for ( i; l ) dst[i] = src[i];
     182        dst[l] = '\0';
     183        return dst;
     184}
     185char * ?=?( char *& dst, string & src ) {
     186        dst = aalloc( len( src ) + 1 );                                 // ensure null terminated
     187        for ( i; len( src ) ) dst[i] = src[i];
     188        dst[len(src)] = '\0';
     189        return dst;
     190}
     191void ?{}( char *& dst, string & src ) {
     192        dst = aalloc( len( src ) + 1 );                                 // ensure null terminated
     193        for ( i; len( src ) ) dst[i] = src[i];
     194        dst[len(src)] = '\0';
     195}
    207196
    208197size_t strnlen( const string & s, size_t maxlen ) { return min( len( s ), maxlen ); }
    … …  
    255244
    256245string ?()( string & s, ssize_t start, ssize_t len ) {
    257         if ( start < 0 ) { start += len( s ); }
    258         if ( len < 0 ) { len = -len; start -= len; }
    259         if ( start >= len( s ) ) return (string){ "" };
     246        if ( start < 0 ) start += len( s );
     247        if ( len < 0 ) { len = -len; start -= len - 1; }
     248        if ( start < 0 || start >= len( s ) ) return (string){ "" };
    260249        if ( start + len > len( s ) ) len = len( s ) - start;
    261250        string ret = { *s.inner, start, len };

  • libcfa/src/collections/string.hfa

    r7ca6bf1 r1dec8f3  
    1010// Created On       : Fri Sep 03 11:00:00 2021
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Apr 13 21:03:35 2025
    13 // Update Count     : 284
     12// Last Modified On : Sun Sep 14 10:58:28 2025
     13// Update Count     : 311
    1414//
    1515
    … …  
    4343void ?{}( string & s, long double _Complex rhs );
    4444static inline void ?{}( string & s, int rhs ) { (s){(signed long int) rhs}; }
    45 
    46 // string str( ssize_t rhs );
    47 // string str( size_t rhs );
    48 // string str( double rhs );
    49 // string str( long double rhs );
    50 // string str( double _Complex rhs );
    51 // string str( long double _Complex rhs );
    5245
    5346PBOOST string & ?=?( string & s, string c );
    … …  
    6861static inline string & strcpy( string & s, const string & c ) { s = c; return s; }
    6962static inline string & strncpy( string & s, const string & c, size_t n ) { assign( s, c, n ); return s; }
     63char * strncpy( char * dst, string & src, size_t n );
     64char * ?=?( char *& dst, string & src );
     65void ?{}( char *& dst, string & src );
    7066
    7167// Alternate construction: request shared edits
    … …  
    187183PBOOST string ?*?( string s, strmul_factor_t factor );
    188184string ?*?( const char * s, strmul_factor_t factor );
    189 static inline string ?*?( strmul_factor_t factor, char s ) { return s * factor; }
     185static inline string ?*?( strmul_factor_t factor, char c ) { return c * factor; }
    190186PBOOST static inline string ?*?( strmul_factor_t factor, string s ) { return s * factor; }
    191187static inline string ?*?( strmul_factor_t factor, const char * s ) { return s * factor; }
    … …  
    278274
    279275size_t include( const string & s, const charclass & mask );
    280 static inline size_t include( const char * cs, const charclass & mask ) { const string s = cs; return include( s, mask ); }
     276static inline size_t include( const string & s, const char * mask ) { return include( s, (charclass){ mask } ); }
     277static inline size_t include( const string & s, const string & mask ) { return include( s, (charclass){ mask } ); }
     278static inline size_t include( const char * cs, const charclass & mask ) { return include( (string){ cs }, mask ); }
     279static inline size_t include( const char * cs, const char * mask ) { return include( (string){ cs }, (charclass){ mask } ); }
     280static inline size_t include( const char * cs, const string & mask ) { return include( (string){ cs }, (charclass){ mask } ); }
     281
    281282static inline string include( const string & s, const charclass & mask ) { return s( 0, include( s, mask ) ); }
     283static inline string include( const string & s, const char * mask ) { return s( 0, include( s, (charclass){ mask } ) ); }
     284static inline string include( const string & s, const string & mask ) { return s( 0, include( s, (charclass){ mask } ) ); }
    282285static inline string include( const char * cs, const charclass & mask ) { const string s = cs; return s( 0, include( s, mask ) ); }
     286static inline string include( const char * cs, const char * mask ) { const string s = cs; return s( 0, include( s, (charclass){ mask } ) ); }
     287static inline string include( const char * cs, const string & mask ) { const string s = cs; return s( 0, include( s, (charclass){ mask } ) ); }
    283288
    284289size_t exclude( const string & s, const charclass & mask );
    285 static inline size_t exclude( const char * cs, const charclass & mask ) { const string s = cs; return exclude( s, mask ); }
     290static inline size_t exclude( const string & s, const char * mask ) { return exclude( s, (charclass){ mask } ); }
     291static inline size_t exclude( const string & s, const string & mask ) { return exclude( s, (charclass){ mask } ); }
     292static inline size_t exclude( const char * cs, const charclass & mask ) { return exclude( (string){ cs }, mask ); }
     293static inline size_t exclude( const char * cs, const string & mask ) { return exclude( (string){ cs }, (charclass){ mask } ); }
     294static inline size_t exclude( const char * cs, const char * mask ) { return exclude( (string){ cs }, (charclass){ mask } ); }
     295
    286296static inline string exclude( const string & s, const charclass & mask ) { return s( 0, exclude( s, mask ) ); }
     297static inline string exclude( const string & s, const char * mask ) { return s( 0, exclude( s, (charclass){ mask } ) ); }
     298static inline string exclude( const string & s, const string & mask ) { return s( 0, exclude( s, (charclass){ mask } ) ); }
    287299static inline string exclude( const char * cs, const charclass & mask ) { const string s = cs; return s( 0, exclude( s, mask ) ); }
    288 
    289 size_t include( const string & s, int (*f)( int ) );
    290 static inline size_t include( const char * cs, int (*f)( int ) ) { const string S = cs; return include( S, f ); }
    291 static inline string include( const string & s, int (*f)( int ) ) { return s( 0, include( s, f ) ); }
    292 static inline string include( const char * cs, int (*f)( int ) ) { const string s = cs; return s( 0, include( s, f ) ); }
    293 
    294 size_t exclude( const string & s, int (*f)( int ) );
    295 static inline size_t exclude( const char * cs, int (*f)( int ) ) { const string s = cs; return exclude( s, f ); }
    296 static inline string exclude( const string & s, int (*f)( int ) ) { return s( 0, exclude( s, f ) ); }
    297 static inline string exclude( const char * cs, int (*f)( int ) ) { const string s = cs; return s( 0, exclude( s, f ) ); }
     300static inline string exclude( const char * cs, const string & mask ) { const string s = cs; return s( 0, exclude( s, (charclass){ mask } ) ); }
     301static inline string exclude( const char * cs, const char * mask ) { const string s = cs; return s( 0, exclude( s, (charclass){ mask } ) ); }
     302
     303size_t include( const string & s, int (* f)( int ) );   // for C character-class functions, e.g., isdigit
     304static inline size_t include( const char * cs, int (* f)( int ) ) { return include( (string){ cs }, f ); }
     305static inline string include( const string & s, int (* f)( int ) ) { return s( 0, include( s, f ) ); }
     306static inline string include( const char * cs, int (* f)( int ) ) { const string s = cs; return s( 0, include( s, f ) ); }
     307
     308static inline size_t include( const string & s, bool (* f)( char ) ) { return include( s, (int (*)( int ))f ); }
     309static inline size_t include( const char * cs, bool (* f)( char ) ) { return include( (string){ cs }, f ); }
     310static inline string include( const string & s, bool (* f)( char ) ) { return s( 0, include( s, f ) ); }
     311static inline string include( const char * cs, bool (* f)( char ) ) { const string s = cs; return s( 0, include( s, f ) ); }
     312
     313size_t exclude( const string & s, int (* f)( int ) );   // for C character-class functions, e.g., isdigit
     314static inline size_t exclude( const char * cs, int (* f)( int ) ) { return exclude( (string){ cs }, f ); }
     315static inline string exclude( const string & s, int (* f)( int ) ) { return s( 0, exclude( s, f ) ); }
     316static inline string exclude( const char * cs, int (* f)( int ) ) { const string s = cs; return s( 0, exclude( s, f ) ); }
     317
     318static inline size_t exclude( const string & s, bool (* f)( char ) ) { return exclude( s, (int (*)( int ))f ); }
     319static inline size_t exclude( const char * cs, bool (* f)( char ) ) { return exclude( (string){ cs }, f ); }
     320static inline string exclude( const string & s, bool (* f)( char ) ) { return s( 0, exclude( s, f ) ); }
     321static inline string exclude( const char * cs, bool (* f)( char ) ) { const string s = cs; return s( 0, exclude( s, f ) ); }
    298322
    299323string replace( const string & s, const string & from, const string & to );
    300 static inline string replace( const char * s, const char * from, const char * to ) { string S = s, From = from, To = to; return replace( S, From, To ); }
    301 static inline string replace( const string & s, const char * from, const char * to ) { const string From = from, To = to; return replace( s, From, To ); }
    302 static inline string replace( const string & s, const char * from, const string & to ) { const string From = from; return replace( s, From, to ); }
    303 static inline string replace( const string & s, string & from, const char * to ) { const string To = to; return replace( s, from, To ); }
    304 
    305 string translate( const string & s, int (*f)( int ) );
    306 static inline string translate( const char * c, int (*f)( int ) ) { const string S = c; return translate( S, f ); }
     324static inline string replace( const char * s, const char * from, const char * to ) { return replace( (string){ s }, (string){ from }, (string){ to } ); }
     325static inline string replace( const string & s, const char * from, const char * to ) { return replace( s, (string){ from }, (string){ to } ); }
     326static inline string replace( const string & s, const char * from, const string & to ) { return replace( s, (string){ from }, to ); }
     327static inline string replace( const string & s, string & from, const char * to ) { return replace( s, from, (string){ to } ); }
     328
     329string translate( const string & s, int (* f)( int ) ); // for C character-class functions, e.g., isdigit
     330static inline string translate( const char * cs, int (* f)( int ) ) { return translate( (string){ cs }, f ); }
     331
     332static inline string translate( const string & s, bool (* f)( char ) ) { return translate( s, (int (*)( int ))f ); }
     333static inline string translate( const char * cs, bool (* f)( char ) ) { return translate( (string){ cs }, f ); }
    307334
    308335#ifndef _COMPILING_STRING_CFA_

  • libcfa/src/concurrency/clib/cfathread.cfa

    r7ca6bf1 r1dec8f3  
    450450        // Condition
    451451        struct cfathread_condition {
    452                 condition_variable(exp_backoff_then_block_lock) impl;
     452                cond_lock(exp_backoff_then_block_lock) impl;
    453453        };
    454454        int cfathread_cond_init(cfathread_cond_t *restrict cond, const cfathread_condattr_t *restrict) __attribute__((nonnull (1))) { *cond = new(); return 0; }

  • libcfa/src/concurrency/locks.cfa

    r7ca6bf1 r1dec8f3  
    246246        struct alarm_node_wrap {
    247247                alarm_node_t alarm_node;
    248                 condition_variable(L) * cond;
     248                cond_lock(L) * cond;
    249249                info_thread(L) * info_thd;
    250250        };
    251251
    252         void ?{}( alarm_node_wrap(L) & this, Duration alarm, Duration period, Alarm_Callback callback, condition_variable(L) * c, info_thread(L) * i ) {
     252        void ?{}( alarm_node_wrap(L) & this, Duration alarm, Duration period, Alarm_Callback callback, cond_lock(L) * c, info_thread(L) * i ) {
    253253                this.alarm_node{ callback, alarm, period };
    254254                this.cond = c;
    … …  
    259259
    260260        static void timeout_handler ( alarm_node_wrap(L) & this ) with( this ) {
    261                 // This condition_variable member is called from the kernel, and therefore, cannot block, but it can spin.
     261                // This cond_lock member is called from the kernel, and therefore, cannot block, but it can spin.
    262262                lock( cond->lock __cfaabi_dbg_ctx2 );
    263263
    … …  
    323323        //-----------------------------------------------------------------------------
    324324        // condition variable
    325         void ?{}( condition_variable(L) & this ){
     325        void ?{}( cond_lock(L) & this ){
    326326                this.lock{};
    327327                this.blocked_threads{};
    … …  
    329329        }
    330330
    331         void ^?{}( condition_variable(L) & this ){ }
    332 
    333         static void process_popped( condition_variable(L) & this, info_thread(L) & popped ) with( this ) {
     331        void ^?{}( cond_lock(L) & this ){ }
     332
     333        static void process_popped( cond_lock(L) & this, info_thread(L) & popped ) with( this ) {
    334334                if (&popped != 0p) {
    335335                        popped.signalled = true;
    … …  
    345345        }
    346346
    347         bool notify_one( condition_variable(L) & this ) with( this ) {
     347        bool notify_one( cond_lock(L) & this ) with( this ) {
    348348                lock( lock __cfaabi_dbg_ctx2 );
    349349                bool ret = ! isEmpty( blocked_threads );
    … …  
    353353        }
    354354
    355         bool notify_all( condition_variable(L) & this ) with(this) {
     355        bool notify_all( cond_lock(L) & this ) with(this) {
    356356                lock( lock __cfaabi_dbg_ctx2 );
    357357                bool ret = ! isEmpty( blocked_threads );
    … …  
    363363        }
    364364
    365         uintptr_t front( condition_variable(L) & this ) with(this) {
     365        uintptr_t front( cond_lock(L) & this ) with(this) {
    366366                return isEmpty( blocked_threads ) ? NULL : first( blocked_threads ).info;
    367367        }
    368368
    369         bool empty( condition_variable(L) & this ) with(this) {
     369        bool empty( cond_lock(L) & this ) with(this) {
    370370                lock( lock __cfaabi_dbg_ctx2 );
    371371                bool ret = isEmpty( blocked_threads );
    … …  
    374374        }
    375375
    376         int counter( condition_variable(L) & this ) with(this) { return count; }
    377 
    378         static void enqueue_thread( condition_variable(L) & this, info_thread(L) * i ) with(this) {
     376        int counter( cond_lock(L) & this ) with(this) { return count; }
     377
     378        static void enqueue_thread( cond_lock(L) & this, info_thread(L) * i ) with(this) {
    379379                // add info_thread to waiting queue
    380380                insert_last( blocked_threads, *i );
    … …  
    393393
    394394        // helper for wait()'s' with no timeout
    395         static void queue_info_thread( condition_variable(L) & this, info_thread(L) & i ) with(this) {
     395        static void queue_info_thread( cond_lock(L) & this, info_thread(L) & i ) with(this) {
    396396                lock( lock __cfaabi_dbg_ctx2 );
    397397                enqueue_thread( this, &i );
    … …  
    412412
    413413        // helper for wait()'s' with a timeout
    414         static void queue_info_thread_timeout( condition_variable(L) & this, info_thread(L) & info, Duration t, Alarm_Callback callback ) with(this) {
     414        static void queue_info_thread_timeout( cond_lock(L) & this, info_thread(L) & info, Duration t, Alarm_Callback callback ) with(this) {
    415415                lock( lock __cfaabi_dbg_ctx2 );
    416416                enqueue_thread( this, &info );
    … …  
    434434                return i.signalled;
    435435
    436         void wait( condition_variable(L) & this ) with(this) { WAIT( 0, 0p ) }
    437         void wait( condition_variable(L) & this, uintptr_t info ) with(this) { WAIT( info, 0p ) }
    438         void wait( condition_variable(L) & this, L & l  ) with(this) { WAIT( 0, &l ) }
    439         void wait( condition_variable(L) & this, L & l, uintptr_t info ) with(this) { WAIT( info, &l ) }
    440 
    441         bool wait( condition_variable(L) & this, Duration duration ) with(this) { WAIT_TIME( 0 , 0p , duration ) }
    442         bool wait( condition_variable(L) & this, uintptr_t info, Duration duration ) with(this) { WAIT_TIME( info, 0p , duration ) }
    443         bool wait( condition_variable(L) & this, L & l, Duration duration  ) with(this) { WAIT_TIME( 0 , &l , duration ) }
    444         bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) { WAIT_TIME( info, &l , duration ) }
     436        void wait( cond_lock(L) & this ) with(this) { WAIT( 0, 0p ) }
     437        void wait( cond_lock(L) & this, uintptr_t info ) with(this) { WAIT( info, 0p ) }
     438        void wait( cond_lock(L) & this, L & l  ) with(this) { WAIT( 0, &l ) }
     439        void wait( cond_lock(L) & this, L & l, uintptr_t info ) with(this) { WAIT( info, &l ) }
     440
     441        bool wait( cond_lock(L) & this, Duration duration ) with(this) { WAIT_TIME( 0 , 0p , duration ) }
     442        bool wait( cond_lock(L) & this, uintptr_t info, Duration duration ) with(this) { WAIT_TIME( info, 0p , duration ) }
     443        bool wait( cond_lock(L) & this, L & l, Duration duration  ) with(this) { WAIT_TIME( 0 , &l , duration ) }
     444        bool wait( cond_lock(L) & this, L & l, uintptr_t info, Duration duration ) with(this) { WAIT_TIME( info, &l , duration ) }
    445445
    446446        //-----------------------------------------------------------------------------

  • libcfa/src/concurrency/locks.hfa

    r7ca6bf1 r1dec8f3  
    1111// Created On       : Thu Jan 21 19:46:50 2021
    1212// Last Modified By : Peter A. Buhr
    13 // Last Modified On : Fri Apr 25 07:14:16 2025
    14 // Update Count     : 22
     13// Last Modified On : Thu Aug 21 22:36:44 2025
     14// Update Count     : 23
    1515//
    1616
    … …  
    797797
    798798        //-----------------------------------------------------------------------------
    799         // condition_variable
     799        // cond_lock
    800800
    801801        // The multi-tool condition variable
    … …  
    805805        // - has shadow queue
    806806        // - can be signalled outside of critical sections with no locks held
    807         struct condition_variable {
     807        struct cond_lock {
    808808                // Spin lock used for mutual exclusion
    809809                __spinlock_t lock;
    … …  
    816816        };
    817817
    818         void ?{}( condition_variable( L ) & this );
    819         void ^?{}( condition_variable( L ) & this );
    820 
    821         bool notify_one( condition_variable( L ) & this );
    822         bool notify_all( condition_variable( L ) & this );
    823 
    824         uintptr_t front( condition_variable( L ) & this );
    825 
    826         bool empty  ( condition_variable( L ) & this );
    827         int  counter( condition_variable( L ) & this );
    828 
    829         void wait( condition_variable( L ) & this );
    830         void wait( condition_variable( L ) & this, uintptr_t info );
    831         bool wait( condition_variable( L ) & this, Duration duration );
    832         bool wait( condition_variable( L ) & this, uintptr_t info, Duration duration );
    833 
    834         void wait( condition_variable( L ) & this, L & l );
    835         void wait( condition_variable( L ) & this, L & l, uintptr_t info );
    836         bool wait( condition_variable( L ) & this, L & l, Duration duration );
    837         bool wait( condition_variable( L ) & this, L & l, uintptr_t info, Duration duration );
     818        void ?{}( cond_lock( L ) & this );
     819        void ^?{}( cond_lock( L ) & this );
     820
     821        bool notify_one( cond_lock( L ) & this );
     822        bool notify_all( cond_lock( L ) & this );
     823
     824        uintptr_t front( cond_lock( L ) & this );
     825
     826        bool empty  ( cond_lock( L ) & this );
     827        int  counter( cond_lock( L ) & this );
     828
     829        void wait( cond_lock( L ) & this );
     830        void wait( cond_lock( L ) & this, uintptr_t info );
     831        bool wait( cond_lock( L ) & this, Duration duration );
     832        bool wait( cond_lock( L ) & this, uintptr_t info, Duration duration );
     833
     834        void wait( cond_lock( L ) & this, L & l );
     835        void wait( cond_lock( L ) & this, L & l, uintptr_t info );
     836        bool wait( cond_lock( L ) & this, L & l, Duration duration );
     837        bool wait( cond_lock( L ) & this, L & l, uintptr_t info, Duration duration );
    838838
    839839        //-----------------------------------------------------------------------------

  • libcfa/src/concurrency/mutex.cfa

    r7ca6bf1 r1dec8f3  
    1212// Created On       : Fri May 25 01:37:11 2018
    1313// Last Modified By : Peter A. Buhr
    14 // Last Modified On : Sun Feb 19 17:01:36 2023
    15 // Update Count     : 3
     14// Last Modified On : Thu Aug 21 22:35:44 2025
     15// Update Count     : 4
    1616//
    1717
    … …  
    131131//-----------------------------------------------------------------------------
    132132// Conditions
    133 void ?{}(condition_variable & this) {
     133void ?{}(cond_lock & this) {
    134134        this.blocked_threads{};
    135135}
    136136
    137 void ^?{}(condition_variable & this) {
     137void ^?{}(cond_lock & this) {
    138138        // default
    139139}
    140140
    141 void notify_one(condition_variable & this) with(this) {
     141void notify_one(cond_lock & this) with(this) {
    142142        lock( lock __cfaabi_dbg_ctx2 );
    143143        unpark(
    … …  
    147147}
    148148
    149 void notify_all(condition_variable & this) with(this) {
     149void notify_all(cond_lock & this) with(this) {
    150150        lock( lock __cfaabi_dbg_ctx2 );
    151151        while(this.blocked_threads) {
    … …  
    157157}
    158158
    159 void wait(condition_variable & this) {
     159void wait(cond_lock & this) {
    160160        lock( this.lock __cfaabi_dbg_ctx2 );
    161161        append( this.blocked_threads, active_thread() );
    … …  
    165165
    166166forall(L & | is_lock(L))
    167 void wait(condition_variable & this, L & l) {
     167void wait(cond_lock & this, L & l) {
    168168        lock( this.lock __cfaabi_dbg_ctx2 );
    169169        append( this.blocked_threads, active_thread() );

  • libcfa/src/concurrency/mutex.hfa

    r7ca6bf1 r1dec8f3  
    1212// Created On       : Fri May 25 01:24:09 2018
    1313// Last Modified By : Peter A. Buhr
    14 // Last Modified On : Thu Feb  2 11:46:08 2023
    15 // Update Count     : 2
     14// Last Modified On : Thu Aug 21 22:35:23 2025
     15// Update Count     : 3
    1616//
    1717
    … …  
    7979// Condition variables
    8080
    81 struct condition_variable {
     81struct cond_lock {
    8282        // Spin lock used for mutual exclusion
    8383        __spinlock_t lock;
    … …  
    8787};
    8888
    89 void ?{}(condition_variable & this) __attribute__((deprecated("use concurrency/locks.hfa instead")));
    90 void ^?{}(condition_variable & this) __attribute__((deprecated("use concurrency/locks.hfa instead")));
     89void ?{}(cond_lock & this) __attribute__((deprecated("use concurrency/locks.hfa instead")));
     90void ^?{}(cond_lock & this) __attribute__((deprecated("use concurrency/locks.hfa instead")));
    9191
    92 void notify_one(condition_variable & this) __attribute__((deprecated("use concurrency/locks.hfa instead")));
    93 void notify_all(condition_variable & this) __attribute__((deprecated("use concurrency/locks.hfa instead")));
     92void notify_one(cond_lock & this) __attribute__((deprecated("use concurrency/locks.hfa instead")));
     93void notify_all(cond_lock & this) __attribute__((deprecated("use concurrency/locks.hfa instead")));
    9494
    95 void wait(condition_variable & this) __attribute__((deprecated("use concurrency/locks.hfa instead")));
     95void wait(cond_lock & this) __attribute__((deprecated("use concurrency/locks.hfa instead")));
    9696
    9797forall(L & | is_lock(L))
    98 void wait(condition_variable & this, L & l) __attribute__((deprecated("use concurrency/locks.hfa instead")));
     98void wait(cond_lock & this, L & l) __attribute__((deprecated("use concurrency/locks.hfa instead")));
    9999
    100100//-----------------------------------------------------------------------------

  • libcfa/src/iostream.hfa

    r7ca6bf1 r1dec8f3  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon May 12 17:29:29 2025
    13 // Update Count     : 769
     12// Last Modified On : Sat Sep 13 16:10:27 2025
     13// Update Count     : 771
    1414//
    1515
Note: See TracChangeset for help on using the changeset viewer.