source: libcfa/src/stdlib.cfa@ 293dc1c

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since 293dc1c was 45444c3, checked in by m3zulfiq <m3zulfiq@…>, 5 years ago

Removed dimension parameter from adelete.
  • Property mode set to 100644
File size: 7.5 KB
RevLine 
[bd85400]1//
2// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
[f4a6101]7// stdlib.c --
[bd85400]8//
9// Author : Peter A. Buhr
10// Created On : Thu Jan 28 17:10:29 2016
[e310238]11// Last Modified By : Peter A. Buhr
12// Last Modified On : Sun Jul 19 15:05:28 2020
13// Update Count : 501
[bd85400]14//
15
[58b6d1b]16#include "stdlib.hfa"
[bd85400]17
18//---------------------------------------
19
20#define _XOPEN_SOURCE 600 // posix_memalign, *rand48
[f3fc631f]21#include <string.h> // memcpy, memset
[89124ff]22//#include <math.h> // fabsf, fabs, fabsl
[6e991d6]23#include <complex.h> // _Complex_I
[e672372]24#include <assert.h>
[bd85400]25
[f4a6101]26//---------------------------------------
27
[6065b3aa]28// allocation/deallocation and constructor/destructor, non-array types
[aca65621]29forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } )
[627f585]30T * new( Params p ) {
[cafb687]31 return &(*malloc()){ p }; // run constructor
[f3ddc21]32} // new
[627f585]33
[aabb846]34forall( dtype T | { void ^?{}( T & ); } )
[627f585]35void delete( T * ptr ) {
[6065b3aa]36 if ( ptr ) { // ignore null
[cafb687]37 ^(*ptr){}; // run destructor
[f3ddc21]38 free( ptr );
[f3fc631f]39 } // if
[f3ddc21]40} // delete
[627f585]41
[aabb846]42forall( dtype T, ttype Params | { void ^?{}( T & ); void delete( Params ); } )
[bf76eab]43void delete( T * ptr, Params rest ) {
[aabb846]44 delete( ptr );
[bf76eab]45 delete( rest );
[f3ddc21]46} // delete
[bf76eab]47
[6065b3aa]48
49// allocation/deallocation and constructor/destructor, array types
[aca65621]50forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } )
[6065b3aa]51T * anew( size_t dim, Params p ) {
[6887a99]52 T * arr = alloc( dim );
[6065b3aa]53 for ( unsigned int i = 0; i < dim; i += 1 ) {
[a493682]54 (arr[i]){ p }; // run constructor
[6065b3aa]55 } // for
56 return arr;
57} // anew
58
[aca65621]59forall( dtype T | sized(T) | { void ^?{}( T & ); } )
[45444c3]60void adelete( T arr[] ) {
[6065b3aa]61 if ( arr ) { // ignore null
[45444c3]62 size_t dim = malloc_size( arr ) / sizeof( T );
[6065b3aa]63 for ( int i = dim - 1; i >= 0; i -= 1 ) { // reverse allocation order, must be unsigned
[a493682]64 ^(arr[i]){}; // run destructor
[6065b3aa]65 } // for
66 free( arr );
67 } // if
68} // adelete
69
[aca65621]70forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } )
[45444c3]71void adelete( T arr[], Params rest ) {
[6065b3aa]72 if ( arr ) { // ignore null
[45444c3]73 size_t dim = malloc_size( arr ) / sizeof( T );
[6065b3aa]74 for ( int i = dim - 1; i >= 0; i -= 1 ) { // reverse allocation order, must be unsigned
[a493682]75 ^(arr[i]){}; // run destructor
[6065b3aa]76 } // for
77 free( arr );
78 } // if
79 adelete( rest );
80} // adelete
81
[bd85400]82//---------------------------------------
83
[e3fea42]84float _Complex strto( const char sptr[], char ** eptr ) {
[bd85400]85 float re, im;
[e672372]86 char * eeptr;
87 re = strtof( sptr, &eeptr );
[bbf3fda]88 if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
[e672372]89 im = strtof( eeptr, &eeptr );
[bbf3fda]90 if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
[e672372]91 if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
[bd85400]92 return re + im * _Complex_I;
[f3ddc21]93} // strto
94
[e3fea42]95double _Complex strto( const char sptr[], char ** eptr ) {
[bd85400]96 double re, im;
[e672372]97 char * eeptr;
98 re = strtod( sptr, &eeptr );
[bbf3fda]99 if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
[e672372]100 im = strtod( eeptr, &eeptr );
[bbf3fda]101 if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
[e672372]102 if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
[bd85400]103 return re + im * _Complex_I;
[f3ddc21]104} // strto
105
[e3fea42]106long double _Complex strto( const char sptr[], char ** eptr ) {
[bd85400]107 long double re, im;
[e672372]108 char * eeptr;
109 re = strtold( sptr, &eeptr );
[bbf3fda]110 if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
[e672372]111 im = strtold( eeptr, &eeptr );
[bbf3fda]112 if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
[e672372]113 if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
[bd85400]114 return re + im * _Complex_I;
[f3ddc21]115} // strto
[bd85400]116
117//---------------------------------------
118
[3ce0d440]119forall( otype E | { int ?<?( E, E ); } ) {
120 E * bsearch( E key, const E * vals, size_t dim ) {
121 int cmp( const void * t1, const void * t2 ) {
122 return *(E *)t1 < *(E *)t2 ? -1 : *(E *)t2 < *(E *)t1 ? 1 : 0;
123 } // cmp
124 return (E *)bsearch( &key, vals, dim, sizeof(E), cmp );
125 } // bsearch
126
127 size_t bsearch( E key, const E * vals, size_t dim ) {
128 E * result = bsearch( key, vals, dim );
129 return result ? result - vals : dim; // pointer subtraction includes sizeof(E)
130 } // bsearch
131
132 size_t bsearchl( E key, const E * vals, size_t dim ) {
133 size_t l = 0, m, h = dim;
134 while ( l < h ) {
135 m = (l + h) / 2;
136 if ( (E &)(vals[m]) < key ) { // cast away const
137 l = m + 1;
138 } else {
139 h = m;
140 } // if
141 } // while
142 return l;
143 } // bsearchl
144
145 E * bsearchl( E key, const E * vals, size_t dim ) {
146 size_t posn = bsearchl( key, vals, dim );
147 return (E *)(&vals[posn]); // cast away const
148 } // bsearchl
149
150 size_t bsearchu( E key, const E * vals, size_t dim ) {
151 size_t l = 0, m, h = dim;
152 while ( l < h ) {
153 m = (l + h) / 2;
154 if ( ! ( key < (E &)(vals[m]) ) ) { // cast away const
155 l = m + 1;
156 } else {
157 h = m;
158 } // if
159 } // while
160 return l;
161 } // bsearchu
162
163 E * bsearchu( E key, const E * vals, size_t dim ) {
164 size_t posn = bsearchu( key, vals, dim );
165 return (E *)(&vals[posn]);
166 } // bsearchu
167
168
169 void qsort( E * vals, size_t dim ) {
170 int cmp( const void * t1, const void * t2 ) {
171 return *(E *)t1 < *(E *)t2 ? -1 : *(E *)t2 < *(E *)t1 ? 1 : 0;
172 } // cmp
173 qsort( vals, dim, sizeof(E), cmp );
174 } // qsort
175} // distribution
176
177
178forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) {
179 E * bsearch( K key, const E * vals, size_t dim ) {
180 int cmp( const void * t1, const void * t2 ) {
181 return *(K *)t1 < getKey( *(E *)t2 ) ? -1 : getKey( *(E *)t2 ) < *(K *)t1 ? 1 : 0;
182 } // cmp
183 return (E *)bsearch( &key, vals, dim, sizeof(E), cmp );
184 } // bsearch
185
186 size_t bsearch( K key, const E * vals, size_t dim ) {
187 E * result = bsearch( key, vals, dim );
188 return result ? result - vals : dim; // pointer subtraction includes sizeof(E)
189 } // bsearch
190
191 size_t bsearchl( K key, const E * vals, size_t dim ) {
192 size_t l = 0, m, h = dim;
193 while ( l < h ) {
194 m = (l + h) / 2;
195 if ( getKey( vals[m] ) < key ) {
196 l = m + 1;
197 } else {
198 h = m;
199 } // if
200 } // while
201 return l;
202 } // bsearchl
203
204 E * bsearchl( K key, const E * vals, size_t dim ) {
205 size_t posn = bsearchl( key, vals, dim );
206 return (E *)(&vals[posn]); // cast away const
207 } // bsearchl
208
209 size_t bsearchu( K key, const E * vals, size_t dim ) {
210 size_t l = 0, m, h = dim;
211 while ( l < h ) {
212 m = (l + h) / 2;
213 if ( ! ( key < getKey( vals[m] ) ) ) {
214 l = m + 1;
215 } else {
216 h = m;
217 } // if
218 } // while
219 return l;
220 } // bsearchu
221
222 E * bsearchu( K key, const E * vals, size_t dim ) {
223 size_t posn = bsearchu( key, vals, dim );
224 return (E *)(&vals[posn]);
225 } // bsearchu
226} // distribution
[bd85400]227
228//---------------------------------------
229
[bbe1a87]230extern "C" { // override C version
231 void srandom( unsigned int seed ) { srand48( (long int)seed ); }
[4e7c0fc0]232 long int random( void ) { return mrand48(); } // GENERATES POSITIVE AND NEGATIVE VALUES
[bbe1a87]233} // extern "C"
234
[e672372]235float random( void ) { return (float)drand48(); } // cast otherwise float uses lrand48
[70e4895d]236double random( void ) { return drand48(); }
237float _Complex random( void ) { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
238double _Complex random( void ) { return drand48() + (double _Complex)(drand48() * _Complex_I); }
[e672372]239long double _Complex random( void ) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
[a9f2c13]240
[2026bb6]241//---------------------------------------
242
243bool threading_enabled(void) __attribute__((weak)) {
244 return false;
245}
[bd85400]246
247// Local Variables: //
248// tab-width: 4 //
249// End: //
Note: See TracBrowser for help on using the repository browser.