Changeset 3ce0d440 for src/libcfa/stdlib


Ignore:
Timestamp:
Jun 2, 2018, 10:00:29 AM (6 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc
Children:
428bef8
Parents:
d56cc219
Message:

more push/pop updates

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/stdlib

    rd56cc219 r3ce0d440  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jun  1 19:52:52 2018
    13 // Update Count     : 302
     12// Last Modified On : Sat Jun  2 08:46:35 2018
     13// Update Count     : 306
    1414//
    1515
    1616#pragma once
    1717
    18 #include <stdlib.h>                                                                             // strto*, *abs
     18#include <stdlib.h>                                                                             // allocation, strto*, *abs
     19extern "C" {
     20        void * memalign( size_t align, size_t size );
     21        void * aligned_alloc( size_t align, size_t size );
     22        void * memset( void * dest, int c, size_t size );
     23} // extern "C"
    1924
    2025//---------------------------------------
    … …  
    2732//---------------------------------------
    2833
    29 // C dynamic allocation
    3034static inline forall( dtype T | sized(T) ) {
     35        // C dynamic allocation
     36
    3137        T * malloc( void ) {
    3238                // printf( "* malloc\n" );
    … …  
    5157        } // realloc
    5258
    53         extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void *
    5459        T * memalign( size_t align ) {
    5560                //printf( "X4\n" );
    … …  
    5762        } // memalign
    5863
    59         extern "C" { void * aligned_alloc( size_t align, size_t size ); } // use default C routine for void *
    6064        T * aligned_alloc( size_t align ) {
    6165                //printf( "X5\n" );
    … …  
    6771                return posix_memalign( (void **)ptr, align, sizeof(T) ); // C posix_memalign
    6872        } // posix_memalign
    69 } // distribution
    70 
    71 // Cforall dynamic allocation
    72 static inline forall( dtype T | sized(T) ) {
    73         extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *
     73
     74
     75        // Cforall dynamic allocation
    7476
    7577        T * alloc( void ) {
    … …  
    104106forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
    105107
    106 static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align ) {
    107         //printf( "X13\n" );
    108         return (T *)memalign( align, sizeof(T) );
    109 } // align_alloc
    110 static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill ) {
    111         //printf( "X14\n" );
    112     T * ptr = (T *)memalign( align, sizeof(T) );
    113     return (T *)memset( ptr, (int)fill, sizeof(T) );
    114 } // align_alloc
    115 
    116 static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ) {
    117         //printf( "X15\n" );
    118         return (T *)memalign( align, dim * sizeof(T) );
    119 } // align_alloc
    120 static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill ) {
    121         //printf( "X16\n" );
    122     T * ptr = (T *)memalign( align, dim * sizeof(T) );
    123     return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
    124 } // align_alloc
    125 
    126 
    127 // data, non-array types
    128 static inline forall( dtype T | sized(T) ) T * memset( T * dest, char c ) {
    129         //printf( "X17\n" );
    130         return (T *)memset( dest, c, sizeof(T) );
    131 } // memset
    132 extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void *
    133 static inline forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src ) {
    134         //printf( "X18\n" );
    135         return (T *)memcpy( dest, src, sizeof(T) );
    136 } // memcpy
    137 
    138 // data, array types
    139 static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) {
    140         //printf( "X19\n" );
    141         return (T *)(void *)memset( dest, c, dim * sizeof(T) ); // C memset
    142 } // memset
    143 static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) {
    144         //printf( "X20\n" );
    145         return (T *)(void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
    146 } // memcpy
     108
     109static inline forall( dtype T | sized(T) ) {
     110        T * align_alloc( size_t align ) {
     111                //printf( "X13\n" );
     112                return (T *)memalign( align, sizeof(T) );
     113        } // align_alloc
     114
     115        T * align_alloc( size_t align, char fill ) {
     116                //printf( "X14\n" );
     117                T * ptr = (T *)memalign( align, sizeof(T) );
     118                return (T *)memset( ptr, (int)fill, sizeof(T) );
     119        } // align_alloc
     120
     121        T * align_alloc( size_t align, size_t dim ) {
     122                //printf( "X15\n" );
     123                return (T *)memalign( align, dim * sizeof(T) );
     124        } // align_alloc
     125
     126        T * align_alloc( size_t align, size_t dim, char fill ) {
     127                //printf( "X16\n" );
     128                T * ptr = (T *)memalign( align, dim * sizeof(T) );
     129                return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
     130        } // align_alloc
     131} // distribution
     132
     133
     134static inline forall( dtype T | sized(T) ) {
     135        // data, non-array types
     136
     137        T * memset( T * dest, char c ) {
     138                //printf( "X17\n" );
     139                return (T *)memset( dest, c, sizeof(T) );
     140        } // memset
     141
     142        extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void *
     143
     144        T * memcpy( T * dest, const T * src ) {
     145                //printf( "X18\n" );
     146                return (T *)memcpy( dest, src, sizeof(T) );
     147        } // memcpy
     148} // distribution
     149
     150static inline forall( dtype T | sized(T) ) {
     151        // data, array types
     152
     153        T * memset( T dest[], size_t dim, char c ) {
     154                //printf( "X19\n" );
     155                return (T *)(void *)memset( dest, c, dim * sizeof(T) ); // C memset
     156        } // memset
     157
     158        T * memcpy( T dest[], const T src[], size_t dim ) {
     159                //printf( "X20\n" );
     160                return (T *)(void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
     161        } // memcpy
     162} // distribution
    147163
    148164// allocation/deallocation and constructor/destructor, non-array types
    … …  
    190206//---------------------------------------
    191207
    192 forall( otype E | { int ?<?( E, E ); } )
    193 E * bsearch( E key, const E * vals, size_t dim );
    194 
    195 forall( otype E | { int ?<?( E, E ); } )
    196 size_t bsearch( E key, const E * vals, size_t dim );
    197 
    198 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    199 E * bsearch( K key, const E * vals, size_t dim );
    200 
    201 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    202 size_t bsearch( K key, const E * vals, size_t dim );
    203 
    204 
    205 forall( otype E | { int ?<?( E, E ); } )
    206 E * bsearchl( E key, const E * vals, size_t dim );
    207 
    208 forall( otype E | { int ?<?( E, E ); } )
    209 size_t bsearchl( E key, const E * vals, size_t dim );
    210 
    211 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    212 E * bsearchl( K key, const E * vals, size_t dim );
    213 
    214 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    215 size_t bsearchl( K key, const E * vals, size_t dim );
    216 
    217 
    218 forall( otype E | { int ?<?( E, E ); } )
    219 E * bsearchu( E key, const E * vals, size_t dim );
    220 
    221 forall( otype E | { int ?<?( E, E ); } )
    222 size_t bsearchu( E key, const E * vals, size_t dim );
    223 
    224 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    225 E * bsearchu( K key, const E * vals, size_t dim );
    226 
    227 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    228 size_t bsearchu( K key, const E * vals, size_t dim );
    229 
    230 
    231 forall( otype E | { int ?<?( E, E ); } )
    232 void qsort( E * vals, size_t dim );
     208forall( otype E | { int ?<?( E, E ); } ) {
     209        E * bsearch( E key, const E * vals, size_t dim );
     210        size_t bsearch( E key, const E * vals, size_t dim );
     211        E * bsearchl( E key, const E * vals, size_t dim );
     212        size_t bsearchl( E key, const E * vals, size_t dim );
     213        E * bsearchu( E key, const E * vals, size_t dim );
     214        size_t bsearchu( E key, const E * vals, size_t dim );
     215
     216        void qsort( E * vals, size_t dim );
     217} // distribution
     218
     219forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) {
     220        E * bsearch( K key, const E * vals, size_t dim );
     221        size_t bsearch( K key, const E * vals, size_t dim );
     222        E * bsearchl( K key, const E * vals, size_t dim );
     223        size_t bsearchl( K key, const E * vals, size_t dim );
     224        E * bsearchu( K key, const E * vals, size_t dim );
     225        size_t bsearchu( K key, const E * vals, size_t dim );
     226} // distribution
    233227
    234228//---------------------------------------
Note: See TracChangeset for help on using the changeset viewer.