Changes in src/libcfa/stdlib [54aba8d:cdbfab0]

File:

• src/libcfa/stdlib (modified) (6 diffs)

src/libcfa/stdlib

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jan  2 12:21:04 2018
-// Update Count     : 292
+// Last Modified On : Tue Oct 31 13:47:24 2017
+// Update Count     : 245
 //
 
 #pragma once
-
-//#define _XOPEN_SOURCE 600                                                             // posix_memalign, *rand48
-#include <stdlib.h>                                                                             // strto*, *abs
 
 //---------------------------------------
@@ -80 +77 @@
         //printf( "X8\n" );
         T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );     // C malloc
-    return (T *)memset( ptr, (int)fill, sizeof(T) );    // initial with fill value
+    return (T *)memset( ptr, (int)fill, sizeof(T) );                    // initial with fill value
 } // alloc
 
@@ -153 +150 @@
 //---------------------------------------
 
-static inline int strto( const char * sptr, char ** eptr, int base ) { return (int)strtol( sptr, eptr, base ); }
-static inline unsigned int strto( const char * sptr, char ** eptr, int base ) { return (unsigned int)strtoul( sptr, eptr, base ); }
-static inline long int strto( const char * sptr, char ** eptr, int base ) { return strtol( sptr, eptr, base ); }
-static inline unsigned long int strto( const char * sptr, char ** eptr, int base ) { return strtoul( sptr, eptr, base ); }
-static inline long long int strto( const char * sptr, char ** eptr, int base ) { return strtoll( sptr, eptr, base ); }
-static inline unsigned long long int strto( const char * sptr, char ** eptr, int base ) { return strtoull( sptr, eptr, base ); }
-
-static inline float strto( const char * sptr, char ** eptr ) { return strtof( sptr, eptr ); }
-static inline double strto( const char * sptr, char ** eptr ) { return strtod( sptr, eptr ); }
-static inline long double strto( const char * sptr, char ** eptr ) { return strtold( sptr, eptr ); }
-
+int ato( const char * ptr );
+unsigned int ato( const char * ptr );
+long int ato( const char * ptr );
+unsigned long int ato( const char * ptr );
+long long int ato( const char * ptr );
+unsigned long long int ato( const char * ptr );
+float ato( const char * ptr );
+double ato( const char * ptr );
+long double ato( const char * ptr );
+float _Complex ato( const char * ptr );
+double _Complex ato( const char * ptr );
+long double _Complex ato( const char * ptr );
+
+int strto( const char * sptr, char ** eptr, int base );
+unsigned int strto( const char * sptr, char ** eptr, int base );
+long int strto( const char * sptr, char ** eptr, int base );
+unsigned long int strto( const char * sptr, char ** eptr, int base );
+long long int strto( const char * sptr, char ** eptr, int base );
+unsigned long long int strto( const char * sptr, char ** eptr, int base );
+float strto( const char * sptr, char ** eptr );
+double strto( const char * sptr, char ** eptr );
+long double strto( const char * sptr, char ** eptr );
 float _Complex strto( const char * sptr, char ** eptr );
 double _Complex strto( const char * sptr, char ** eptr );
 long double _Complex strto( const char * sptr, char ** eptr );
 
-static inline int ato( const char * sptr ) {return (int)strtol( sptr, 0, 10 ); }
-static inline unsigned int ato( const char * sptr ) { return (unsigned int)strtoul( sptr, 0, 10 ); }
-static inline long int ato( const char * sptr ) { return strtol( sptr, 0, 10 ); }
-static inline unsigned long int ato( const char * sptr ) { return strtoul( sptr, 0, 10 ); }
-static inline long long int ato( const char * sptr ) { return strtoll( sptr, 0, 10 ); }
-static inline unsigned long long int ato( const char * sptr ) { return strtoull( sptr, 0, 10 ); }
-
-static inline float ato( const char * sptr ) { return strtof( sptr, 0 ); }
-static inline double ato( const char * sptr ) { return strtod( sptr, 0 ); }
-static inline long double ato( const char * sptr ) { return strtold( sptr, 0 ); }
-
-static inline float _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
-static inline double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
-static inline long double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
-
-//---------------------------------------
-
-forall( otype E | { int ?<?( E, E ); } )
-E * bsearch( E key, const E * vals, size_t dim );
-
-forall( otype E | { int ?<?( E, E ); } )
-size_t bsearch( E key, const E * vals, size_t dim );
-
-forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
-E * bsearch( K key, const E * vals, size_t dim );
-
-forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
-size_t bsearch( K key, const E * vals, size_t dim );
-
-
-forall( otype E | { int ?<?( E, E ); } )
-E * bsearchl( E key, const E * vals, size_t dim );
-
-forall( otype E | { int ?<?( E, E ); } )
-size_t bsearchl( E key, const E * vals, size_t dim );
-
-forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
-E * bsearchl( K key, const E * vals, size_t dim );
-
-forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
-size_t bsearchl( K key, const E * vals, size_t dim );
-
-
-forall( otype E | { int ?<?( E, E ); } )
-E * bsearchu( E key, const E * vals, size_t dim );
-
-forall( otype E | { int ?<?( E, E ); } )
-size_t bsearchu( E key, const E * vals, size_t dim );
-
-forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
-E * bsearchu( K key, const E * vals, size_t dim );
-
-forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
-size_t bsearchu( K key, const E * vals, size_t dim );
-
-
-forall( otype E | { int ?<?( E, E ); } )
-void qsort( E * vals, size_t dim );
+//---------------------------------------
+
+forall( otype T | { int ?<?( T, T ); } )
+T * bsearch( T key, const T * arr, size_t dim );
+
+forall( otype T | { int ?<?( T, T ); } )
+unsigned int bsearch( T key, const T * arr, size_t dim );
+
+
+forall( otype T | { int ?<?( T, T ); } )
+void qsort( const T * arr, size_t dim );
 
 //---------------------------------------
@@ -237 +198 @@
 //---------------------------------------
 
-static inline unsigned char abs( signed char v ) { return abs( (int)v ); }
+unsigned char abs( signed char );
 extern "C" { int abs( int ); }                                                  // use default C routine for int
-static inline unsigned long int abs( long int v ) { return labs( v ); }
-static inline unsigned long long int abs( long long int v ) { return llabs( v ); }
-
-extern "C" {
-double fabs( double );
-float fabsf( float );
-long double fabsl( long double );
-} // extern "C"
-static inline float abs( float x ) { return fabsf( x ); }
-static inline double abs( double x ) { return fabs( x ); }
-static inline long double abs( long double x ) { return fabsl( x ); }
-
-extern "C" {
-double cabs( double _Complex );
-float cabsf( float _Complex );
-long double cabsl( long double _Complex );
-} // extern "C"
-static inline float abs( float _Complex x ) { return cabsf( x ); }
-static inline double abs( double _Complex x ) { return cabs( x ); }
-static inline long double abs( long double _Complex x ) { return cabsl( x ); }
-
+unsigned long int abs( long int );
+unsigned long long int abs( long long int );
+float abs( float );
+double abs( double );
+long double abs( long double );
+float abs( float _Complex );
+double abs( double _Complex );
+long double abs( long double _Complex );
 forall( otype T | { void ?{}( T &, zero_t ); int ?<?( T, T ); T -?( T ); } )
 T abs( T );
@@ -265 +213 @@
 //---------------------------------------
 
-extern "C" { void srandom( unsigned int seed ); }               // override C version
+void random_seed( long int s );
 char random( void );
-char random( char u );
 char random( char l, char u );
 int random( void );
-int random( int u );
-int random( int l, int u );
 unsigned int random( void );
 unsigned int random( unsigned int u );
 unsigned int random( unsigned int l, unsigned int u );
-extern "C" { long int random( void ); }                                 // override C version
-long int random( long int u );
-long int random( long int l, long int u );
+//long int random( void );
 unsigned long int random( void );
 unsigned long int random( unsigned long int u );
@@ -290 +233 @@
 
 forall( otype T | { int ?<?( T, T ); } )
-static inline T min( T t1, T t2 ) { return t1 < t2 ? t1 : t2; }
+T min( T t1, T t2 );
 
 forall( otype T | { int ?>?( T, T ); } )
-static inline T max( T t1, T t2 ) { return t1 > t2 ? t1 : t2; }
+T max( T t1, T t2 );
 
 forall( otype T | { T min( T, T ); T max( T, T ); } )
-static inline T clamp( T value, T min_val, T max_val ) { return max( min_val, min( value, max_val ) ); }
+T clamp( T value, T min_val, T max_val );
 
 forall( otype T )
-static inline void swap( T & v1, T & v2 ) { T temp = v1; v1 = v2; v2 = temp; }
+void swap( T & t1, T & t2 );
 
 // Local Variables: //