Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • tests/alloc.cfa

    rfe23950 r6a25b8f  
    1010// Created On       : Wed Feb  3 07:56:22 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Nov 12 10:02:18 2020
    13 // Update Count     : 432
     12// Last Modified On : Fri Nov 22 15:34:19 2019
     13// Update Count     : 404
    1414//
    1515
    … …  
    2828        size_t dim = 10;
    2929        char fill = '\xde';
    30         int * ip, * ip1;
     30        int * p, * p1;
    3131
    3232        // allocation, non-array types
    3333
    34         ip = (int *)malloc( sizeof(*ip) );                                      // C malloc, type unsafe
    35         *ip = 0xdeadbeef;
    36         printf( "C   malloc %#x\n", *ip );
    37         free( ip );
    38 
    39         ip = malloc();                                                                          // CFA malloc, type safe
    40         *ip = 0xdeadbeef;
    41         printf( "CFA malloc %#x\n", *ip );
    42         free( ip );
    43 
    44         ip = alloc();                                                                           // CFA alloc, type safe
    45         *ip = 0xdeadbeef;
    46         printf( "CFA alloc %#x\n", *ip );
    47         free( ip );
    48 
    49         ip = alloc( fill`fill );                                                                // CFA alloc, fill
    50         printf( "CFA alloc, fill %08x\n", *ip );
    51         free( ip );
    52 
    53         ip = alloc( 3`fill );                                                           // CFA alloc, fill
    54         printf( "CFA alloc, fill %d\n", *ip );
    55         free( ip );
     34        p = (int *)malloc( sizeof(*p) );                                        // C malloc, type unsafe
     35        *p = 0xdeadbeef;
     36        printf( "C   malloc %#x\n", *p );
     37        free( p );
     38
     39        p = malloc();                                       // CFA malloc, type safe
     40        *p = 0xdeadbeef;
     41        printf( "CFA malloc %#x\n", *p );
     42        free( p );
     43
     44        p = alloc();                                        // CFA alloc, type safe
     45        *p = 0xdeadbeef;
     46        printf( "CFA alloc %#x\n", *p );
     47        free( p );
     48
     49        p = alloc_set( fill );                                                          // CFA alloc, fill
     50        printf( "CFA array alloc, fill %#hhx\n", fill );
     51        printf( "CFA alloc, fill %08x\n", *p );
     52        free( p );
     53
     54        p = alloc_set( 3 );                                                                     // CFA alloc, fill
     55        printf( "CFA alloc, fill %d\n", *p );
     56        free( p );
    5657
    5758
    … …  
    5960        printf( "\n" );
    6061
    61         ip = (int *)calloc( dim, sizeof( *ip ) );                       // C array calloc, type unsafe
     62        p = (int *)calloc( dim, sizeof( *p ) );                         // C array calloc, type unsafe
    6263        printf( "C   array calloc, fill 0\n" );
    63         for ( i; dim ) { printf( "%#x ", ip[i] ); }
    64         printf( "\n" );
    65         free( ip );
    66 
    67         ip = calloc( dim );                                                                     // CFA array calloc, type safe
     64        for ( i; dim ) { printf( "%#x ", p[i] ); }
     65        printf( "\n" );
     66        free( p );
     67
     68        p = calloc( dim );                                  // CFA array calloc, type safe
    6869        printf( "CFA array calloc, fill 0\n" );
    69         for ( i; dim ) { printf( "%#x ", ip[i] ); }
    70         printf( "\n" );
    71         free( ip );
    72 
    73         ip = alloc( dim );                                                                      // CFA array alloc, type safe
    74         for ( i; dim ) { ip[i] = 0xdeadbeef; }
     70        for ( i; dim ) { printf( "%#x ", p[i] ); }
     71        printf( "\n" );
     72        free( p );
     73
     74        p = alloc( dim );                                   // CFA array alloc, type safe
     75        for ( i; dim ) { p[i] = 0xdeadbeef; }
    7576        printf( "CFA array alloc, no fill\n" );
    76         for ( i; dim ) { printf( "%#x ", ip[i] ); }
    77         printf( "\n" );
    78         free( ip );
    79 
    80         ip = alloc( 2 * dim, fill`fill );                                       // CFA array alloc, fill
     77        for ( i; dim ) { printf( "%#x ", p[i] ); }
     78        printf( "\n" );
     79        free( p );
     80
     81        p = alloc_set( 2 * dim, fill );                                         // CFA array alloc, fill
    8182        printf( "CFA array alloc, fill %#hhx\n", fill );
    82         for ( i; 2 * dim ) { printf( "%#x ", ip[i] ); }
    83         printf( "\n" );
    84         free( ip );
    85 
    86         ip = alloc( 2 * dim, ((int)0xdeadbeef)`fill );                          // CFA array alloc, fill
     83        for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
     84        printf( "\n" );
     85        free( p );
     86
     87        p = alloc_set( 2 * dim, 0xdeadbeef );                           // CFA array alloc, fill
    8788        printf( "CFA array alloc, fill %#hhx\n", 0xdeadbeef );
    88         for ( i; 2 * dim ) { printf( "%#x ", ip[i] ); }
    89         printf( "\n" );
    90         // do not free
    91 
    92         ip1 = alloc( 2 * dim, [ip, 2 * dim]`fill );                             // CFA array alloc, fill
     89        for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
     90        printf( "\n" );
     91        // do not free
     92
     93        p1 = alloc_set( 2 * dim, p );                                           // CFA array alloc, fill
    9394        printf( "CFA array alloc, fill from array\n" );
    94         for ( i; 2 * dim ) { printf( "%#x %#x, ", ip[i], ip1[i] ); }
    95         free( ip1 );
    96         printf( "\n" );
    97 
    98 
    99         // realloc, non-array types
    100         printf( "\n" );
    101 
    102         ip = (int *)realloc( ip, dim * sizeof(*ip) );           // C realloc
     95        for ( i; 2 * dim ) { printf( "%#x %#x, ", p[i], p1[i] ); }
     96        free( p1 );
     97        printf( "\n" );
     98
     99
     100        // resize, non-array types
     101        printf( "\n" );
     102
     103        p = (int *)realloc( p, dim * sizeof(*p) );                      // C realloc
    103104        printf( "C realloc\n" );
    104         for ( i; dim ) { printf( "%#x ", ip[i] ); }
    105         printf( "\n" );
    106         // do not free
    107 
    108         ip = realloc( ip, 2 * dim * sizeof(*ip) );                      // CFA realloc
    109         for ( i; dim ~ 2 * dim ) { ip[i] = 0x1010101; }
     105        for ( i; dim ) { printf( "%#x ", p[i] ); }
     106        printf( "\n" );
     107        // do not free
     108
     109        p = realloc( p, 2 * dim * sizeof(*p) );             // CFA realloc
     110        for ( i; dim ~ 2 * dim ) { p[i] = 0x1010101; }
    110111        printf( "CFA realloc\n" );
    111         for ( i; 2 * dim ) { printf( "%#x ", ip[i] ); }
    112         printf( "\n" );
    113         // do not free
    114 
    115 
    116         // realloc, array types
    117         printf( "\n" );
    118 
    119         ip = alloc( dim, ip`realloc );                                                          // CFA realloc array alloc
    120         for ( i; dim ) { ip[i] = 0xdeadbeef; }
    121         printf( "CFA realloc array alloc\n" );
    122         for ( i; dim ) { printf( "%#x ", ip[i] ); }
    123         printf( "\n" );
    124         // do not free
    125 
    126         ip = alloc( 2 * dim, ip`realloc );                                                      // CFA realloc array alloc
    127         for ( i; dim ~ 2 * dim ) { ip[i] = 0x1010101; }         // fill upper part
    128         printf( "CFA realloc array alloc\n" );
    129         for ( i; 2 * dim ) { printf( "%#x ", ip[i] ); }
    130         printf( "\n" );
    131         // do not free
    132 
    133         ip = alloc( dim, ip`realloc );                                                          // CFA realloc array alloc
    134         printf( "CFA realloc array alloc\n" );
    135         for ( i; dim ) { printf( "%#x ", ip[i] ); }
    136         printf( "\n" );
    137         // do not free
    138 
    139         ip = alloc( 3 * dim, ip`realloc, fill`fill );                           // CFA realloc array alloc, fill
    140         printf( "CFA realloc array alloc, fill\n" );
    141         for ( i; 3 * dim ) { printf( "%#x ", ip[i] ); }
    142         printf( "\n" );
    143         // do not free
    144 
    145         ip = alloc( dim, ip`realloc, fill`fill );                                       // CFA realloc array alloc, fill
    146         printf( "CFA realloc array alloc, fill\n" );
    147         for ( i; dim ) { printf( "%#x ", ip[i] ); }
    148         printf( "\n" );
    149         // do not free
    150 
    151         ip = alloc( 3 * dim, ip`realloc, fill`fill );                           // CFA realloc array alloc, fill
    152         printf( "CFA realloc array alloc, fill\n" );
    153         for ( i; 3 * dim ) { printf( "%#x ", ip[i] ); }
    154         printf( "\n" );
    155         // do not free
    156 #if 0 // FIX ME
    157         ip = alloc( 5 * dim, ip`realloc, 5`fill );                                      // CFA realloc array alloc, 5
    158         printf( "CFA realloc array alloc, 5\n" );
    159         for ( i; 5 * dim ) { printf( "%#x ", ip[i] ); }
    160         printf( "\n" );
    161         // do not free
    162 
    163         ip = alloc( dim, ip`realloc, 5`fill );                                          // CFA realloc array alloc, 5
    164         printf( "CFA realloc array alloc, 5\n" );
    165         for ( i; dim ) { printf( "%#x ", ip[i] ); }
    166         printf( "\n" );
    167         // do not free
    168 
    169         ip = alloc( 5 * dim, ip`realloc, 5`fill );                                      // CFA realloc array alloc, 5
    170         printf( "CFA realloc array alloc, 5\n" );
    171         for ( i; 5 * dim ) { printf( "%#x ", ip[i] ); }
    172         printf( "\n" );
    173 #endif // 0
    174         free( ip );
    175 
    176         // resize, non-array types
    177 
    178         struct S {
    179                 int a[5];
    180         };
    181 
    182     ip = alloc();
    183         *ip = 5;
    184     double * dp = alloc( ip`resize );
    185         *dp = 5.5;
    186     S * sp = alloc( dp`resize );
    187         *sp = (S){ {0, 1, 2, 3, 4} };
    188     ip = alloc( sp`resize );
    189         *ip = 3;
    190     free( ip );
     112        for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
     113        printf( "\n" );
     114        // do not free
    191115
    192116
    193117        // resize, array types
    194 
    195     ip = alloc( 5 );
    196         for ( i; 5 ) { ip[i] = 5; }
    197     dp = alloc( 5, ip`resize );
    198         for ( i; 5 ) { dp[i] = 5.5; }
    199     sp = alloc( 5, dp`resize );
    200         for ( i; 5 ) { sp[i] = (S){ {0, 1, 2, 3, 4} }; }
    201     ip = alloc( 3, sp`resize );
    202         for ( i; 3 ) { ip[i] = 3; }
    203     ip = alloc( 7, ip`realloc );
    204         for ( i; 7 ) { ip[i] = 7; }
    205     ip = alloc( 7, ip`resize );
    206         for ( i; 7 ) { ip[i] = 7; }
    207     free( ip );
    208 
    209 
    210         int const_count, dest_count;
     118        printf( "\n" );
     119
     120        p = alloc( p, dim );                                // CFA resize array alloc
     121        for ( i; dim ) { p[i] = 0xdeadbeef; }
     122        printf( "CFA resize array alloc\n" );
     123        for ( i; dim ) { printf( "%#x ", p[i] ); }
     124        printf( "\n" );
     125        // do not free
     126
     127        p = alloc( p, 2 * dim );                            // CFA resize array alloc
     128        for ( i; dim ~ 2 * dim ) { p[i] = 0x1010101; }          // fill upper part
     129        printf( "CFA resize array alloc\n" );
     130        for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
     131        printf( "\n" );
     132        // do not free
     133
     134        p = alloc( p, dim );                                // CFA resize array alloc
     135        printf( "CFA resize array alloc\n" );
     136        for ( i; dim ) { printf( "%#x ", p[i] ); }
     137        printf( "\n" );
     138        // do not free
     139
     140        p = alloc_set( p, 3 * dim, fill );                                      // CFA resize array alloc, fill
     141        printf( "CFA resize array alloc\n" );
     142        for ( i; 3 * dim ) { printf( "%#x ", p[i] ); }
     143        printf( "\n" );
     144        // do not free
     145
     146        p = alloc_set( p, dim, fill );                                          // CFA resize array alloc, fill
     147        printf( "CFA resize array alloc\n" );
     148        for ( i; dim ) { printf( "%#x ", p[i] ); }
     149        printf( "\n" );
     150        // do not free
     151
     152        p = alloc_set( p, 3 * dim, fill );                                      // CFA resize array alloc, fill
     153        printf( "CFA resize array alloc, fill\n" );
     154        for ( i; 3 * dim ) { printf( "%#x ", p[i] );; }
     155        printf( "\n" );
     156        free( p );
     157
     158
    211159        struct Struct { int x; double y; };
    212         void  ?{}( Struct & a ) {                                       // construct
    213                 a.[ x, y ] = [ -1, -1.0 ];
    214         }
    215         void  ?{}( Struct & a, int x, double y ) {      // initialize
    216                 a.[ x, y ] = [ x, y ];
    217                 const_count++;
    218         }
    219         void ^?{}( Struct & a ) {  dest_count++; }      // destruct
    220160        Struct st, st1, sta[dim], sta1[dim], * stp, * stp1;
    221161
    … …  
    229169        free( stp );
    230170
    231         stp = &(*memalign( Alignment )){ 42, 42.5 };            // CFA memalign
     171        stp = &(*memalign( Alignment )){ 42, 42.5 };          // CFA memalign
    232172        assert( (uintptr_t)stp % Alignment == 0 );
    233173        printf( "CFA memalign %d %g\n", stp->x, stp->y );
    … …  
    246186        free( stp );
    247187
    248         stp = &(*alloc( Alignment`align)){ 42, 42.5 };          // CFA alloc_align
     188        stp = &(*alloc_align( Alignment)){ 42, 42.5 };          // CFA alloc_align
    249189        assert( (uintptr_t)stp % Alignment == 0 );
    250190        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
    251191        free( stp );
    252192
    253         stp = &(*alloc( Alignment`align )){ 42, 42.5 };         // CFA alloc_align
     193        stp = &(*alloc_align( Alignment )){ 42, 42.5 };         // CFA alloc_align
    254194        assert( (uintptr_t)stp % Alignment == 0 );
    255195        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
    256196        free( stp );
    257197
    258         stp = alloc( Alignment`align, fill`fill );                      // CFA memalign, fill
     198        stp = alloc_align_set( Alignment, fill );                       // CFA memalign, fill
    259199        assert( (uintptr_t)stp % Alignment == 0 );
    260200        printf( "CFA alloc_align fill %#x %a\n", stp->x, stp->y );
    261201        free( stp );
    262202
    263         stp = alloc( Alignment`align, (Struct){ 42, 42.5 }`fill ); // CFA memalign, fill
     203        stp = alloc_align_set( Alignment, (Struct){ 42, 42.5 } ); // CFA memalign, fill
    264204        assert( (uintptr_t)stp % Alignment == 0 );
    265205        printf( "CFA alloc_align fill %d %g\n", stp->x, stp->y );
    266206        // do not free
    267207
    268         stp = &(*alloc( stp`realloc, 4096`align )){ 42, 42.5 };         // CFA realign
     208        stp = &(*alloc_align( stp, 4096 )){ 42, 42.5 };         // CFA realign
    269209        assert( (uintptr_t)stp % 4096 == 0 );
    270210        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
    … …  
    275215        printf( "\n" );
    276216
    277         stp = alloc( dim, Alignment`align );                // CFA array memalign
     217        stp = alloc_align( Alignment, dim );                // CFA array memalign
    278218        assert( (uintptr_t)stp % Alignment == 0 );
    279219        for ( i; dim ) { stp[i] = (Struct){ 42, 42.5 }; }
    … …  
    283223        free( stp );
    284224
    285         stp = alloc( dim, Alignment`align, fill`fill );         // CFA array memalign, fill
     225        stp = alloc_align_set( Alignment, dim, fill );          // CFA array memalign, fill
    286226        assert( (uintptr_t)stp % Alignment == 0 );
    287227        printf( "CFA array alloc_align, fill\n" );
    … …  
    290230        free( stp );
    291231
    292         stp = alloc( dim, Alignment`align, ((Struct){ 42, 42.5 })`fill ); // CFA array memalign, fill
     232        stp = alloc_align_set( Alignment, dim, (Struct){ 42, 42.5 } ); // CFA array memalign, fill
    293233        assert( (uintptr_t)stp % Alignment == 0 );
    294234        printf( "CFA array alloc_align, fill\n" );
    … …  
    297237        // do not free
    298238
    299         stp1 = alloc( dim, Alignment`align, [stp, dim]`fill );  // CFA array memalign, fill
     239        stp1 = alloc_align_set( Alignment, dim, stp );          // CFA array memalign, fill
    300240        assert( (uintptr_t)stp % Alignment == 0 );
    301241        printf( "CFA array alloc_align, fill array\n" );
    … …  
    304244        free( stp1 );
    305245
    306         stp = alloc( dim, stp`realloc, 4096`align );                            // CFA aligned realloc array
     246        stp = alloc_align( stp, 4096, dim );                            // CFA aligned realloc array
    307247        assert( (uintptr_t)stp % 4096 == 0 );
    308248        for ( i; dim ) { stp[i] = (Struct){ 42, 42.5 }; }
    … …  
    335275        printf( "\n" );
    336276
     277
    337278        // new, non-array types
    338279        printf( "\n" );
    339280
    340         const_count = dest_count = 0;
    341281        stp = new( 42, 42.5 );
    342         assert( const_count == 1 && dest_count == 0 );                                          // assertion for testing
    343282        stp1 = new( 42, 42.5 );
    344         assert( const_count == 2 && dest_count == 0 );                                          // assertion for testing
    345 
    346283        printf( "CFA new initialize\n%d %g %d %g\n", stp->x, stp->y, stp1->x, stp1->y );
    347284        delete( stp, stp1 );
    348         assert( const_count == 2 && dest_count == 2 );                                          // assertion for testing
    349285
    350286        // new, array types
    351287        stp = anew( dim, 42, 42.5 );
    352         assert( const_count == 2 + dim && dest_count == 2 );                            // assertion for testing
    353288        printf( "CFA array new initialize\n" );
    354289        for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
    355290        printf( "\n" );
    356 
    357291        stp1 = anew( dim, 42, 42.5 );
    358         assert( const_count == 2 + 2 * dim && dest_count == 2 );                        // assertion for testing
    359292        for ( i; dim ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
    360293        printf( "\n" );
    361         adelete( stp, stp1 );
    362         assert( const_count == 2 + 2 * dim && dest_count == 2 + 2 * dim);       // assertion for testing
     294        adelete( dim, stp, dim, stp1 );
    363295
    364296        // extras
    … …  
    369301        free( fp - 1 );
    370302
    371         ip = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
    372         *ip = 0xdeadbeef;
    373         printf( "CFA deep malloc %#x\n", *ip );
    374 
    375         dp = alloc(5.0`fill); // just for testing multiple free
    376         assert(*dp == 5.0);
    377         free( ip, dp, 0p );
     303        p = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
     304        *p = 0xdeadbeef;
     305        printf( "CFA deep malloc %#x\n", *p );
     306        free( p );
    378307
    379308#ifdef ERR1
    380309        stp = malloc();
    381310        printf( "\nSHOULD FAIL\n" );
    382         ip = realloc( stp, dim * sizeof( *stp ) );
    383         ip = memset( stp, 10 );
    384         ip = memcpy( &st1, &st );
    385 #endif // ERR1
     311        p = realloc( stp, dim * sizeof( *stp ) );
     312        p = alloc( stp, dim * sizeof( *stp ) );
     313        p = memset( stp, 10 );
     314        p = memcpy( &st1, &st );
     315#endif
    386316} // main
    387317
Note: See TracChangeset for help on using the changeset viewer.