Index: doc/user/user.tex =================================================================== --- doc/user/user.tex (revision 9c1600c894d713bbdc06ea2e3299d4c08cfdff3a) +++ doc/user/user.tex (revision acd738aa4b3c107e0d22096954fcb98fa69acfe6) @@ -11,6 +11,6 @@ %% Created On : Wed Apr 6 14:53:29 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Tue May 30 11:45:46 2017 -%% Update Count : 2098 +%% Last Modified On : Thu Jun 1 22:46:09 2017 +%% Update Count : 2126 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -5242,77 +5242,86 @@ \begin{description} \item[fill] -after allocation the storage is or is not filled with a specified character. +after allocation the storage is filled with a specified character. \item[resize] an existing allocation is decreased or increased in size. In either case, new storage may or may not be allocated and, if there is a new allocation, as much data from the existing allocation is copied. -For an increase in storage size, new storage after the copied data may or may not be filled. +For an increase in storage size, new storage after the copied data may be filled. \item[alignment] an allocation starts on a specified memory boundary, e.g., an address multiple of 64 or 128 for cache-line purposes. \item[array] the allocation size is scaled to the specified number of array elements. -An array may or not be filled, resized, or aligned. +An array may be filled, resized, or aligned. \end{description} - -The following table show the allocation routines supporting different combinations of storage-management capabilities: +The table shows allocation routines supporting different combinations of storage-management capabilities: \begin{center} -\begin{tabular}{@{}r|l|l|l|l@{}} - & fill & resize & alignment & array \\ +\begin{tabular}{@{}lr|l|l|l|l@{}} + & & \multicolumn{1}{c|}{fill} & resize & alignment & array \\ \hline -©malloc© & no/yes & no/yes & no & no \\ -©amalloc© & no/copy data/yes & no/yes & no & yes \\ -©calloc© & yes (0 only) & no & no & yes \\ -©realloc© & no/copy data & yes & no & no \\ -©memalign© & no/yes & no & yes & no \\ -©amemalign© & no/yes & no & yes & yes \\ -©align_alloc© & no & no & yes & no \\ -©posix_memalign© & no & no & yes & no \\ +C & ©malloc© & no & no & no & no \\ + & ©calloc© & yes (0 only) & no & no & yes \\ + & ©realloc© & no/copy & yes & no & no \\ + & ©memalign© & no & no & yes & no \\ + & ©posix_memalign© & no & no & yes & no \\ +C11 & ©aligned_alloc© & no & no & yes & no \\ +\CFA & ©alloc© & no/copy/yes & no/yes & no & yes \\ + & ©align_alloc© & no/yes & no & yes & yes \\ \end{tabular} \end{center} -% When ©amalloc© resizes and fills, the space after the copied data from the source is set to the fill character. It is impossible to resize with alignment because the underlying ©realloc© allocates storage if more space is needed, and it does not honour alignment from the original allocation. \leavevmode \begin{cfa}[aboveskip=0pt,belowskip=0pt] -// allocation, non-array types -forall( dtype T | sized(T) ) T * malloc( void );§\indexc{malloc}§ -forall( dtype T | sized(T) ) T * malloc( char fill ); - -// allocation, array types -forall( dtype T | sized(T) ) T * calloc( size_t dim );§\indexc{cmalloc}§ -forall( dtype T | sized(T) ) T * amalloc( size_t dim );§\indexc{amalloc}§ // alternate name for calloc -forall( dtype T | sized(T) ) T * amalloc( size_t dim, char fill ); - -// resize, non-array types -forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size );§\indexc{realloc}§ -forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ); -forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ); // alternate name for realloc -forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, char fill ); - -// resize, array types -forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim ); -forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim, char fill ); - -// alignment, non-array types -forall( dtype T | sized(T) ) T * memalign( size_t alignment );§\indexc{memalign}§ -forall( dtype T | sized(T) ) T * memalign( size_t alignment, char fill ); -forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment );§\indexc{aligned_alloc}§ -forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment );§\indexc{posix_memalign}§ - -// alignment, array types -forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim );§\indexc{amemalign}§ -forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim, char fill ); - -// data, non-array types +// C unsafe allocation +extern "C" { void * mallac( size_t size ); }§\indexc{memset}§ +extern "C" { void * calloc( size_t dim, size_t size ); }§\indexc{calloc}§ +extern "C" { void * realloc( void * ptr, size_t size ); }§\indexc{realloc}§ +extern "C" { void * memalign( size_t align, size_t size ); }§\indexc{memalign}§ +extern "C" { int posix_memalign( void ** ptr, size_t align, size_t size ); }§\indexc{posix_memalign}§ + +// §\CFA§ safe equivalents, i.e., implicit size specification +forall( dtype T | sized(T) ) T * malloc( void ); +forall( dtype T | sized(T) ) T * calloc( size_t dim ); +forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ); +forall( dtype T | sized(T) ) T * memalign( size_t align ); +forall( dtype T | sized(T) ) T * aligned_alloc( size_t align ); +forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align ); + +// §\CFA§ safe general allocation, fill, resize, array +forall( dtype T | sized(T) ) T * alloc( void );§\indexc{alloc}§ +forall( dtype T | sized(T) ) T * alloc( char fill ); +forall( dtype T | sized(T) ) T * alloc( size_t dim ); +forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill ); +forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim ); +forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ); + +// §\CFA§ safe general allocation, align, fill, array +forall( dtype T | sized(T) ) T * align_alloc( size_t align ); +forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill ); +forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ); +forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill ); + +// C unsafe initialization/copy +extern "C" { void * memset( void * dest, int c, size_t size ); } +extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } + +// §\CFA§ safe initialization/copy forall( dtype T | sized(T) ) T * memset( T * dest, char c );§\indexc{memset}§ forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src );§\indexc{memcpy}§ -// data, array types -forall( dtype T | sized(T) ) T * amemset( T * dest, size_t dim, char c );§\indexc{amemset}§ -forall( dtype T | sized(T) ) T * amemcpy( T * dest, const T * src, size_t dim );§\indexc{amemcpy}§ - -// allocation/deallocation and constructor/destructor -forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p );§\indexc{new}§ +// §\CFA§ safe initialization/copy array +forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ); +forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ); + +// §\CFA§ allocation/deallocation and constructor/destructor +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p );§\indexc{new}§ forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr );§\indexc{delete}§ -forall( dtype T, ttype Params | { void ^?{}( T * ); void delete(Params); } ) void delete( T * ptr, Params rest ); +forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) + void delete( T * ptr, Params rest ); + +// §\CFA§ allocation/deallocation and constructor/destructor, array +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p );§\indexc{anew}§ +forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] );§\indexc{adelete}§ +forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) + void adelete( size_t dim, T arr[], Params rest ); \end{cfa} Index: src/Common/PassVisitor.h =================================================================== --- src/Common/PassVisitor.h (revision 9c1600c894d713bbdc06ea2e3299d4c08cfdff3a) +++ src/Common/PassVisitor.h (revision acd738aa4b3c107e0d22096954fcb98fa69acfe6) @@ -26,13 +26,11 @@ template< typename... Args > - PassVisitor(Args &&... args) + PassVisitor(Args &&... args) : pass( std::forward( args )... ) {} virtual ~PassVisitor() = default; -private: + pass_type pass; - -public: virtual void visit( ObjectDecl *objectDecl ) override final; Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision 9c1600c894d713bbdc06ea2e3299d4c08cfdff3a) +++ src/InitTweak/FixInit.cc (revision acd738aa4b3c107e0d22096954fcb98fa69acfe6) @@ -192,14 +192,13 @@ }; - class FixInit final : public GenPoly::PolyMutator { + class FixInit { public: /// expand each object declaration to use its constructor after it is declared. static void fixInitializers( std::list< Declaration * > &translationUnit ); - typedef GenPoly::PolyMutator Parent; - using Parent::mutate; - virtual DeclarationWithType * mutate( ObjectDecl *objDecl ) override; + DeclarationWithType * postmutate( ObjectDecl *objDecl ); std::list< Declaration * > staticDtorDecls; + std::list< Statement * > stmtsToAddAfter; // found by PassVisitor }; @@ -312,5 +311,5 @@ void FixInit::fixInitializers( std::list< Declaration * > & translationUnit ) { - FixInit fixer; + PassVisitor fixer; // can't use mutateAll, because need to insert declarations at top-level @@ -320,5 +319,5 @@ try { *i = maybeMutate( *i, fixer ); - translationUnit.splice( i, fixer.staticDtorDecls ); + translationUnit.splice( i, fixer.pass.staticDtorDecls ); } catch( SemanticError &e ) { e.set_location( (*i)->location ); @@ -696,8 +695,6 @@ } - DeclarationWithType *FixInit::mutate( ObjectDecl *objDecl ) { - // first recursively handle pieces of ObjectDecl so that they aren't missed by other visitors when the init - // is removed from the ObjectDecl - objDecl = dynamic_cast< ObjectDecl * >( Parent::mutate( objDecl ) ); + DeclarationWithType *FixInit::postmutate( ObjectDecl *objDecl ) { + // since this removes the init field from objDecl, it must occur after children are mutated (i.e. postmutate) if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) { // a decision should have been made by the resolver, so ctor and init are not both non-NULL Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision 9c1600c894d713bbdc06ea2e3299d4c08cfdff3a) +++ src/Parser/lex.ll (revision acd738aa4b3c107e0d22096954fcb98fa69acfe6) @@ -5,11 +5,11 @@ * file "LICENCE" distributed with Cforall. * - * lex.l -- + * lex.ll -- * * Author : Peter A. Buhr * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Mon May 22 07:46:30 2017 - * Update Count : 525 + * Last Modified On : Tue May 30 22:00:48 2017 + * Update Count : 527 */ @@ -235,5 +235,5 @@ long { KEYWORD_RETURN(LONG); } lvalue { KEYWORD_RETURN(LVALUE); } // CFA -monitor { KEYWORD_RETURN(MONITOR); } // CFA +monitor { KEYWORD_RETURN(MONITOR); } // CFA mutex { KEYWORD_RETURN(MUTEX); } // CFA _Noreturn { KEYWORD_RETURN(NORETURN); } // C11 Index: src/libcfa/stdlib =================================================================== --- src/libcfa/stdlib (revision 9c1600c894d713bbdc06ea2e3299d4c08cfdff3a) +++ src/libcfa/stdlib (revision acd738aa4b3c107e0d22096954fcb98fa69acfe6) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:12:35 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 30 09:07:35 2017 -// Update Count : 164 +// Last Modified On : Thu Jun 1 22:46:43 2017 +// Update Count : 216 // @@ -28,6 +28,4 @@ //--------------------------------------- -extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void * - // allocation, non-array types static inline forall( dtype T | sized(T) ) T * malloc( void ) { @@ -35,83 +33,83 @@ return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc } // malloc -static inline forall( dtype T | sized(T) ) T * malloc( char fill ) { + +extern "C" { void * calloc( size_t dim, size_t size ); } // default C routine +static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) { //printf( "X2\n" ); + return (T *)(void *)calloc( dim, sizeof(T) ); // C cmalloc +} + +extern "C" { void * realloc( void * ptr, size_t size ); } // default C routine for void * +static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) { + //printf( "X3\n" ); + return (T *)(void *)realloc( (void *)ptr, size ); +} + +extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void * +static inline forall( dtype T | sized(T) ) T * memalign( size_t align ) { + //printf( "X4\n" ); + return (T *)memalign( align, sizeof(T) ); +} // memalign + +static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t align ) { + //printf( "X5\n" ); + return (T *)memalign( align, sizeof(T) ); +} // aligned_alloc + +extern "C" { int posix_memalign( void ** ptr, size_t align, size_t size ); } // use default C routine for void * +static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align ) { + //printf( "X6\n" ); + return posix_memalign( (void **)ptr, align, sizeof(T) ); +} // posix_memalign + + +extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void * + +static inline forall( dtype T | sized(T) ) T * alloc( void ) { + //printf( "X7\n" ); + return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc +} // alloc +static inline forall( dtype T | sized(T) ) T * alloc( char fill ) { + //printf( "X8\n" ); T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc return memset( ptr, (int)fill, sizeof(T) ); // initial with fill value -} // malloc - -// allocation, array types -extern "C" { void * calloc( size_t dim, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) { - //printf( "X3\n" ); - return (T *)(void *)calloc( dim, sizeof(T) ); // C cmalloc -} -static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim ) { // alternative name - //printf( "X4\n" ); +} // alloc + +static inline forall( dtype T | sized(T) ) T * alloc( size_t dim ) { + //printf( "X9\n" ); return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc -} // amalloc -static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim, char fill ) { // alternative name - //printf( "X5\n" ); +} // alloc +static inline forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill ) { + //printf( "X10\n" ); T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc return memset( ptr, (int)fill, dim * sizeof(T) ); -} // amalloc - -// resize, non-array types -extern "C" { void * realloc( void * ptr, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) { - //printf( "X5.5\n" ); - return (T *)(void *)realloc( (void *)ptr, size ); -} -forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ); -static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) { // alternative name - //printf( "X7\n" ); - return realloc( ptr, size ); -} // malloc -static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, char fill ) { // alternative name - //printf( "X8\n" ); - return realloc( ptr, size, fill ); -} // malloc - -// resize, array types -static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim ) { - //printf( "X9\n" ); - return malloc( ptr, dim * (size_t)sizeof(T) ); -} // amalloc -static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim, char fill ) { - //printf( "X10\n" ); - return malloc( ptr, dim * (size_t)sizeof(T), fill ); -} // amalloc - -// alignment, non-array types -extern "C" { void * memalign( size_t alignment, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment ) { +} // alloc + +static inline forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim ) { //printf( "X11\n" ); - return (T *)memalign( alignment, sizeof(T) ); -} // memalign -static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment, char fill ) { - //printf( "X12\n" ); - T * ptr = (T *)memalign( alignment, sizeof(T) ); + return (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc +} // alloc +forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ); + +static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align ) { + //printf( "X13\n" ); + return (T *)memalign( align, sizeof(T) ); +} // align_alloc +static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill ) { + //printf( "X14\n" ); + T * ptr = (T *)memalign( align, sizeof(T) ); return memset( ptr, (int)fill, sizeof(T) ); -} // memalign -static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) { - //printf( "X13\n" ); - return (T *)memalign( alignment, sizeof(T) ); -} // aligned_alloc -extern "C" { int posix_memalign( void ** ptr, size_t alignment, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ) { - //printf( "X14\n" ); - return posix_memalign( (void **)ptr, alignment, sizeof(T) ); -} // posix_memalign - -// alignment, array types -static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim ) { +} // align_alloc + +static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ) { //printf( "X15\n" ); - return (T *)memalign( alignment, dim * sizeof(T) ); -} // amemalign -static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim, char fill ) { + return (T *)memalign( align, dim * sizeof(T) ); +} // align_alloc +static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill ) { //printf( "X16\n" ); - T * ptr = (T *)memalign( alignment, dim * sizeof(T) ); + T * ptr = (T *)memalign( align, dim * sizeof(T) ); return memset( ptr, (int)fill, dim * sizeof(T) ); -} // amemalign +} // align_alloc + // data, non-array types @@ -127,17 +125,22 @@ // data, array types -static inline forall( dtype T | sized(T) ) T * amemset( T * dest, size_t dim, char c ) { +static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) { //printf( "X19\n" ); return memset( dest, c, dim * sizeof(T) ); -} // amemset -static inline forall( dtype T | sized(T) ) T * amemcpy( T * dest, const T * src, size_t dim ) { +} // memset +static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) { //printf( "X20\n" ); - return memcpy( dest, src, dim * sizeof(T) ); -} // amemcpy - -// allocation/deallocation and constructor/destructor -forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p ); + return (void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy +} // memcpy + +// allocation/deallocation and constructor/destructor, non-array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p ); forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr ); forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest ); + +// allocation/deallocation and constructor/destructor, array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p ); +forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] ); +forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest ); //--------------------------------------- Index: src/libcfa/stdlib.c =================================================================== --- src/libcfa/stdlib.c (revision 9c1600c894d713bbdc06ea2e3299d4c08cfdff3a) +++ src/libcfa/stdlib.c (revision acd738aa4b3c107e0d22096954fcb98fa69acfe6) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:10:29 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 30 09:07:56 2017 -// Update Count : 237 +// Last Modified On : Thu Jun 1 21:52:57 2017 +// Update Count : 280 // @@ -28,8 +28,7 @@ // resize, non-array types -forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ) { // alternative realloc with fill value - //printf( "X6\n" ); +forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ) { size_t olen = malloc_usable_size( ptr ); // current allocation - char * nptr = (void *)realloc( (void *)ptr, size ); // C realloc + char * nptr = (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc size_t nlen = malloc_usable_size( nptr ); // new allocation if ( nlen > olen ) { // larger ? @@ -37,15 +36,15 @@ } // return (T *)nptr; -} // realloc - -// allocation/deallocation and constructor/destructor -forall( dtype T, ttype Params | sized(T) | { void ?{}( T *, Params ); } ) +} // alloc + +// allocation/deallocation and constructor/destructor, non-array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p ) { - return ((T *)malloc()){ p }; + return (malloc()){ p }; // run constructor } // new forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr ) { - if ( ptr ) { + if ( ptr ) { // ignore null ^ptr{}; // run destructor free( ptr ); @@ -55,5 +54,5 @@ forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest ) { - if ( ptr ) { + if ( ptr ) { // ignore null ^ptr{}; // run destructor free( ptr ); @@ -61,4 +60,36 @@ delete( rest ); } // delete + + +// allocation/deallocation and constructor/destructor, array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) +T * anew( size_t dim, Params p ) { + T *arr = alloc( dim ); + for ( unsigned int i = 0; i < dim; i += 1 ) { + (&arr[i]){ p }; // run constructor + } // for + return arr; +} // anew + +forall( dtype T | sized(T) | { void ^?{}( T * ); } ) +void adelete( size_t dim, T arr[] ) { + if ( arr ) { // ignore null + for ( int i = dim - 1; i >= 0; i -= 1 ) { // reverse allocation order, must be unsigned + ^(&arr[i]){}; // run destructor + } // for + free( arr ); + } // if +} // adelete + +forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) +void adelete( size_t dim, T arr[], Params rest ) { + if ( arr ) { // ignore null + for ( int i = dim - 1; i >= 0; i -= 1 ) { // reverse allocation order, must be unsigned + ^(&arr[i]){}; // run destructor + } // for + free( arr ); + } // if + adelete( rest ); +} // adelete //--------------------------------------- Index: src/tests/.expect/alloc.txt =================================================================== --- src/tests/.expect/alloc.txt (revision 9c1600c894d713bbdc06ea2e3299d4c08cfdff3a) +++ src/tests/.expect/alloc.txt (revision acd738aa4b3c107e0d22096954fcb98fa69acfe6) @@ -1,56 +1,63 @@ -C malloc deadbeef -CFA malloc 0 -CFA malloc, fill 01010101 +C malloc 0xdeadbeef +CFA malloc 0xdeadbeef +CFA alloc 0xdeadbeef +CFA alloc, fill 01010101 -C calloc +C array calloc, fill 0 0 0 0 0 0 0 0 0 0 0 -CFA calloc +CFA array calloc, fill 0 0 0 0 0 0 0 0 0 0 0 -CFA array malloc -0 0 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA array malloc -1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 +CFA array alloc, no fill +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef +CFA array alloc, fill 0x1 +0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 -C realloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA realloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 0 0 0 0 0 0 0 0 0 0 -CFA realloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA resize malloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA resize malloc, fill -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 -CFA resize malloc, fill -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef +C realloc 40 +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef +CFA realloc 88 +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 -CFA resize array malloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 0 0 0 0 0 0 0 0 0 0 -CFA resize array malloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA resize array malloc, fill -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 -CFA resize array malloc, fill -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef +CFA resize alloc 40 +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef +CFA resize array alloc 88 +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 +CFA resize array alloc 40 +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef +CFA resize array alloc 40, fill +0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 +CFA resize array alloc 88, fill +0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 +CFA resize array alloc 40, fill +0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 -CFA aligned_alloc 42 42.5 +C memalign 42 42.5 CFA memalign 42 42.5 CFA posix_memalign 42 42.5 -CFA memalign fill 16843009 7.7486e-304 +CFA posix_memalign 42 42.5 +CFA aligned_alloc 42 42.5 +CFA align_alloc 42 42.5 +CFA align_alloc fill 0x1010101 0x1.1010101010101p-1007 -CFA memalign array -0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, -CFA memalign array -1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, +CFA array align_alloc +42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, +CFA array align_alloc, fill +0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, -CFA memset ffffffff -nan -CFA memcpy ffffffff -nan +CFA memset 0x1010101 0x1.1010101010101p-1007 +CFA memcpy 0x1010101 0x1.1010101010101p-1007 CFA array memset -ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, +0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, CFA memcpy -deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, +0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, + +CFA new initialize +42 42.5 42 42.5 +CFA array new initialize +42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, +42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, + pointer arithmetic 0 -CFA deep malloc deadbeef +CFA deep malloc 0xdeadbeef SHOULD FAIL Index: src/tests/alloc.c =================================================================== --- src/tests/alloc.c (revision 9c1600c894d713bbdc06ea2e3299d4c08cfdff3a) +++ src/tests/alloc.c (revision acd738aa4b3c107e0d22096954fcb98fa69acfe6) @@ -10,6 +10,6 @@ // Created On : Wed Feb 3 07:56:22 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon May 29 11:33:15 2017 -// Update Count : 228 +// Last Modified On : Thu Jun 1 21:33:49 2017 +// Update Count : 315 // @@ -18,4 +18,5 @@ #include // malloc_usable_size #include // uintptr_t +#include // posix_memalign } // extern #include @@ -28,6 +29,6 @@ int main( void ) { size_t dim = 10; - struct S { int x; double y; } * s; int * p; + char fill = '\1'; // allocation, non-array types @@ -35,13 +36,19 @@ p = (void *)malloc( sizeof(*p) ); // C malloc, type unsafe *p = 0xdeadbeef; - printf( "C malloc %x\n", *p ); + printf( "C malloc %#x\n", *p ); free( p ); p = malloc(); // CFA malloc, type safe - printf( "CFA malloc %d\n", *p ); - free( p ); - - p = malloc( '\1' ); // CFA malloc, fill - printf( "CFA malloc, fill %08x\n", *p ); + *p = 0xdeadbeef; + printf( "CFA malloc %#x\n", *p ); + free( p ); + + p = alloc(); // CFA alloc, type safe + *p = 0xdeadbeef; + printf( "CFA alloc %#x\n", *p ); + free( p ); + + p = alloc( fill ); // CFA alloc, fill + printf( "CFA alloc, fill %08x\n", *p ); @@ -50,24 +57,25 @@ p = calloc( dim, sizeof( *p ) ); // C array calloc, type unsafe - printf( "C calloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + printf( "C array calloc, fill 0\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); free( p ); p = calloc( dim ); // CFA array calloc, type safe - printf( "CFA calloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - free( p ); - - p = amalloc( dim ); // CFA array malloc, type safe - printf( "CFA array malloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - free( p ); - - p = amalloc( 2 * dim, '\1' ); // CFA array malloc, fill - printf( "CFA array malloc\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + printf( "CFA array calloc, fill 0\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + free( p ); + + p = alloc( dim ); // CFA array alloc, type safe + for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } + printf( "CFA array alloc, no fill\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + free( p ); + + p = alloc( 2 * dim, fill ); // CFA array alloc, fill + printf( "CFA array alloc, fill %#x\n", fill ); + for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); // do not free @@ -77,32 +85,14 @@ printf( "\n" ); - p = (void *)realloc( p, dim * sizeof(*p) ); // CFA realloc - printf( "C realloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + p = (void *)realloc( p, dim * sizeof(*p) ); // C realloc + for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } + printf( "C realloc %ld\n", malloc_usable_size( p ) ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); p = realloc( p, 2 * dim * sizeof(*p) ); // CFA realloc - printf( "CFA realloc\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = realloc( p, dim * sizeof(*p), '\1' ); // CFA realloc - printf( "CFA realloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = malloc( p, dim * sizeof(*p) ); // CFA malloc - printf( "CFA resize malloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = malloc( p, 2 * dim * sizeof(*p), '\1' ); // CFA malloc, fill - printf( "CFA resize malloc, fill\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = malloc( p, dim * sizeof(*p), '\1' ); // CFA malloc, fill - printf( "CFA resize malloc, fill\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; } + printf( "CFA realloc %ld\n", malloc_usable_size( p ) ); + for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); // do not free @@ -112,43 +102,62 @@ printf( "\n" ); - p = amalloc( p, 2 * dim ); // CFA array malloc - printf( "CFA resize array malloc\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = amalloc( p, dim ); // CFA array malloc - printf( "CFA resize array malloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = amalloc( p, 2 * dim, '\1' ); // CFA array malloc, fill - printf( "CFA resize array malloc, fill\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = amalloc( p, dim, '\1' ); // CFA array malloc, fill - printf( "CFA resize array malloc, fill\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + p = alloc( p, dim ); // CFA resize array alloc + for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } + printf( "CFA resize alloc %ld\n", malloc_usable_size( p ) ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + + p = alloc( p, 2 * dim ); // CFA resize array alloc + for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; } + printf( "CFA resize array alloc %ld\n", malloc_usable_size( p ) ); + for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + + p = alloc( p, dim ); // CFA array alloc + printf( "CFA resize array alloc %ld\n", malloc_usable_size( p ) ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + free( p ); - printf( "\n" ); + p = 0; + + p = alloc( p, dim, fill ); // CFA array alloc, fill + printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + + p = alloc( p, 2 * dim, fill ); // CFA array alloc, fill + printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) ); + for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + + p = alloc( p, dim, fill ); // CFA array alloc, fill + printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] );; } + printf( "\n" ); + free( p ); + struct Struct { int x; double y; }; - Struct st, st1, sta[dim], sta1[dim], * stp; - + Struct st, st1, sta[dim], sta1[dim], * stp, * stp1; // alignment, non-array types printf( "\n" ); - enum { Alignment = 128 }; - stp = aligned_alloc( Alignment ); // CFA aligned_alloc + + stp = (memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "C memalign %d %g\n", stp->x, stp->y ); + free( stp ); + + stp = (memalign( Alignment )){ 42, 42.5 }; // CFA memalign + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA memalign %d %g\n", stp->x, stp->y ); + free( stp ); + + posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign *stp = (Struct){ 42, 42.5 }; assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y ); - free( stp ); - - stp = memalign( Alignment ); // CFA memalign - *stp = (Struct){ 42, 42.5 }; - assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA memalign %d %g\n", stp->x, stp->y ); + printf( "CFA posix_memalign %d %g\n", stp->x, stp->y ); free( stp ); @@ -159,7 +168,17 @@ free( stp ); - stp = memalign( Alignment, '\1' ); // CFA memalign, fill - assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA memalign fill %d %g\n", stp->x, stp->y ); + stp = (aligned_alloc( Alignment )){ 42, 42.5 }; // CFA aligned_alloc + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y ); + free( stp ); + + stp = (align_alloc( Alignment )){ 42, 42.5 }; // CFA align_alloc + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA align_alloc %d %g\n", stp->x, stp->y ); + free( stp ); + + stp = align_alloc( Alignment, fill ); // CFA memalign, fill + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA align_alloc fill %#x %a\n", stp->x, stp->y ); free( stp ); @@ -168,15 +187,16 @@ printf( "\n" ); - stp = amemalign( Alignment, 2 * dim ); // CFA array memalign - assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA memalign array\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x %g, ", stp[i].x, stp[i].y ); stp[i].x = 0Xdeadbeef, stp[i].y = -17.2; } - printf( "\n" ); - free( stp ); - - stp = amemalign( Alignment, dim, '\1' ); // CFA array memalign, fill - assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA memalign array\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x %g, ", stp[i].x, stp[i].y ); stp[i].x = 0Xdeadbeef, stp[i].y = -17.2; } + stp = align_alloc( Alignment, dim ); // CFA array memalign + assert( (uintptr_t)stp % Alignment == 0 ); + for ( int i = 0; i < dim; i += 1 ) { stp[i] = (Struct){ 42, 42.5 }; } + printf( "CFA array align_alloc\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); } + printf( "\n" ); + free( stp ); + + stp = align_alloc( Alignment, dim, fill ); // CFA array memalign, fill + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA array align_alloc, fill\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); } printf( "\n" ); free( stp ); @@ -186,8 +206,8 @@ printf( "\n" ); - stp = memset( &st, '\xff' ); // CFA memset, type safe - printf( "CFA memset %x %g\n", st.x, st.y ); - stp = memcpy( &st1, &st ); // CFA memcpy, type safe - printf( "CFA memcpy %x %g\n", st1.x, st1.y ); + memset( &st, fill ); // CFA memset, type safe + printf( "CFA memset %#x %a\n", st.x, st.y ); + memcpy( &st1, &st ); // CFA memcpy, type safe + printf( "CFA memcpy %#x %a\n", st1.x, st1.y ); @@ -195,12 +215,34 @@ printf( "\n" ); - stp = amemset( sta, dim, '\xff' ); // CFA array memset, type safe + memset( sta, dim, fill ); // CFA array memset, type safe printf( "CFA array memset\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x %g, ", sta[i].x, sta[i].y ); sta[i].x = 0Xdeadbeef, sta[i].y = -17.2; } - printf( "\n" ); - - stp = amemcpy( sta1, sta, dim ); // CFA array memcpy, type safe + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); } + printf( "\n" ); + + memcpy( sta1, sta, dim ); // CFA array memcpy, type safe printf( "CFA memcpy\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x %g, ", sta1[i].x, sta1[i].y ); sta1[i].x = 0Xdeadbeef, sta1[i].y = -17.2; } + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); } + printf( "\n" ); + + + // new, non-array types + printf( "\n" ); + + stp = new( 42, 42.5 ); + stp1 = new( 42, 42.5 ); + printf( "CFA new initialize\n%d %g %d %g\n", stp->x, stp->y, stp1->x, stp1->y ); + delete( stp, stp1 ); + + // new, array types + stp = anew( dim, 42, 42.5 ); + printf( "CFA array new initialize\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); } + printf( "\n" ); + stp1 = anew( dim, 42, 42.5 ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); } + printf( "\n" ); + adelete( dim, stp, dim, stp1 ); + + // extras printf( "\n" ); @@ -211,10 +253,10 @@ p = foo( bar( baz( malloc(), 0 ), 0 ), 0 ); *p = 0xdeadbeef; - printf( "CFA deep malloc %x\n", *p ); + printf( "CFA deep malloc %#x\n", *p ); free( p ); stp = malloc(); printf( "\nSHOULD FAIL\n" ); - p = malloc( stp, dim * sizeof(*stp) ); + p = alloc( stp, dim * sizeof(*stp) ); p = memset( stp, 10 ); p = memcpy( &st1, &st ); Index: src/tests/test.py =================================================================== --- src/tests/test.py (revision 9c1600c894d713bbdc06ea2e3299d4c08cfdff3a) +++ src/tests/test.py (revision acd738aa4b3c107e0d22096954fcb98fa69acfe6) @@ -253,5 +253,5 @@ # for each test to run try : - results = pool.map_async(partial(run_test_worker, generate=generate, dry_run=dry_run, debug=debug), tests, chunksize = 1 ).get(3600) + results = pool.map_async(partial(run_test_worker, generate=generate, dry_run=dry_run, debug=debug), tests, chunksize = 1 ).get(7200) except KeyboardInterrupt: pool.terminate()