Ignore:
Timestamp:
Nov 12, 2020, 1:29:43 PM (11 months ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
b5344a3
Parents:
d6ad99e (diff), 8ca26d5 (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 branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:
1 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/stdlib.hfa

    rd6ad99e r9d264e1  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Sep  1 20:32:34 2020
    13 // Update Count     : 505
     12// Last Modified On : Thu Nov 12 08:12:08 2020
     13// Update Count     : 515
    1414//
    1515
    1616#pragma once
    1717
    18 #include "bits/defs.hfa"
    19 #include "bits/align.hfa"
     18#include "bits/defs.hfa"                                                                // OPTIONAL_THREAD
     19#include "bits/align.hfa"                                                               // libAlign
    2020
    2121#include <stdlib.h>                                                                             // *alloc, strto*, ato*
     
    107107} // distribution
    108108
    109 static inline forall( ttype TT | { void free( TT ); } ) {
    110         // T* does not take void* and vice-versa
    111 
    112         void free( void * addr, TT rest ) {
    113                 free( addr );
    114                 free( rest );
    115         } // free
    116 
    117         forall( dtype T | sized(T) )
    118         void free( T * addr, TT rest ) {
    119                 free( addr );
    120                 free( rest );
    121         } // free
    122 } // distribution
    123 
    124109/*
    125110        FIX ME : fix alloc interface after Ticker Number 214 is resolved, define and add union to S_fill. Then, modify postfix-fill functions to support T * with nmemb, char, and T object of any size. Finally, change alloc_internal.
     
    129114                forall( dtype T | sized(T) ) {
    130115                        union  U_fill           { char c; T * a; T t; };
    131                         struct S_fill           { char tag; char c; size_t size; T * at; char t[50]; };
     116                        struct S_fill           { char tag; U_fill(T) fill; };
    132117                        struct S_realloc        { inline T *; };
    133118                }
     
    177162static inline T_align   ?`align   ( size_t a )  { return (T_align){a}; }
    178163static inline T_resize  ?`resize  ( void * a )  { return (T_resize){a}; }
     164
    179165static inline forall( dtype T | sized(T) ) {
    180 
    181166        S_fill(T) ?`fill ( T t ) {
    182167                S_fill(T) ret = { 't' };
     
    250235
    251236        } // distribution TT
    252 
    253237} // distribution T
    254238
     
    262246                return (T *)memcpy( dest, src, sizeof(T) );
    263247        } // memcpy
    264 } // distribution
    265 
    266 static inline forall( dtype T | sized(T) ) {
     248
    267249        // Cforall safe initialization/copy, i.e., implicit size specification, array types
    268250        T * amemset( T dest[], char fill, size_t dim ) {
     
    275257} // distribution
    276258
     259// Cforall deallocation for multiple objects
     260static inline forall( dtype T, ttype TT | { void free( TT ); } )
     261void free( T * addr, TT rest ) {
     262        free( addr );
     263        free( rest );
     264} // free
     265
    277266// Cforall allocation/deallocation and constructor/destructor, non-array types
    278 forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p );
    279 forall( dtype T | { void ^?{}( T & ); } ) void delete( T * ptr );
    280 forall( dtype T, ttype Params | { void ^?{}( T & ); void delete( Params ); } ) void delete( T * ptr, Params rest );
     267static inline forall( dtype T | sized(T), ttype TT | { void ?{}( T &, TT ); } )
     268T * new( TT p ) {
     269        return &(*malloc()){ p };                                                       // run constructor
     270} // new
     271
     272static inline forall( dtype T | { void ^?{}( T & ); } )
     273void delete( T * ptr ) {
     274        if ( ptr ) {                                                                            // ignore null
     275                ^(*ptr){};                                                                              // run destructor
     276                free( ptr );
     277        } // if
     278} // delete
     279
     280static inline forall( dtype T, ttype TT | { void ^?{}( T & ); void delete( TT ); } )
     281void delete( T * ptr, TT rest ) {
     282        delete( ptr );
     283        delete( rest );
     284} // delete
    281285
    282286// Cforall allocation/deallocation and constructor/destructor, array types
    283 forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );
     287forall( dtype T | sized(T), ttype TT | { void ?{}( T &, TT ); } ) T * anew( size_t dim, TT p );
    284288forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( T arr[] );
    285 forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } ) void adelete( T arr[], Params rest );
     289forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype TT | { void adelete( TT ); } ) void adelete( T arr[], TT rest );
    286290
    287291//---------------------------------------
     
    379383//---------------------------------------
    380384
    381 extern bool threading_enabled(void) OPTIONAL_THREAD;
     385extern bool threading_enabled( void ) OPTIONAL_THREAD;
    382386
    383387// Local Variables: //
Note: See TracChangeset for help on using the changeset viewer.