git.maemo.org Git - opencv/blob - apps/Hawk/CVEiCL/EiC/module/stdClib/src/stdlib.h

   1 #ifndef _STDLIBH
   2 #define _STDLIBH
   3
   4 #pragma push_safeptr
   5
   6 #define _need_size_t
   7 #define _need_NULL
   8
   9 #include "sys/stdtypes.h"
  10
  11 #undef _need_NULL
  12 #undef _need_size_t
  13
  14 #include <sys/stdlib.h>
  15
  16
  17 typedef struct {
  18     int quot, rem;
  19 }div_t;
  20
  21 typedef struct {
  22     long quot, rem;
  23 }ldiv_t;
  24
  25
  26 /* declaration prototypes */
  27
  28 div_t div(int numer, int denom);
  29 ldiv_t ldiv(long int numer, long int denom);
  30
  31 void * malloc(size_t n);
  32 void * calloc(size_t x, size_t y);
  33 void * realloc(void * ptr, size_t n);
  34
  35 #if defined(_EiC) && 0
  36 #define  free(x)  (free)(&(x));
  37 #endif
  38
  39 void  (free)(void *ptr);
  40
  41
  42 int rand(void);
  43 void srand(unsigned int seed);
  44 double strtod(const char *str, char **endptr);
  45 long strtol(const char *str, char **endptr,int base);
  46
  47 #ifndef _SUNOS
  48 unsigned long strtoul(const char *str, char **endptr,int base);
  49 #else
  50 #define strtoul(x,y,z)         strtol(x,y,z)
  51 #endif
  52
  53 int system(const char * str);
  54 double atof(const char *str);
  55 int atoi(const char *s);
  56 long atol(const char *s);
  57
  58 char *getenv(const char *name);
  59 int *putenv(const char *name);
  60
  61 void exit(int eval);
  62 int atexit(void f(void));
  63 void abort(void);
  64
  65 /* these two macros are unsafe */
  66 #define abs(x)     ((x)>0? (x):-(x))
  67 #define labs(x)    abs(x)
  68
  69 /* non-standard stuff EiC interpreter stuff*/
  70 #ifdef _EiC
  71 #define itoa(x,y,z)     _itoa(x,y,z,1)
  72 #define utoa(x,y,z)     _itoa(x,y,z,2)
  73 #define ltoa(x,y,z)     _ltoa(x,y,z,1)
  74 #define ultoa(x,y,z)    _ltoa(x,y,z,2)
  75 #else
  76 char *utoa(unsigned int n, char *s, int radix);
  77 char *itoa(int n, char *s, int radix);
  78 char *ultoa(unsigned long n, char *s, int radix);
  79 char *ltoa(long n, char *s, int radix);
  80 #endif /* end EiC */
  81
  82 #if defined(_SUNOS) && !defined(_EiC)
  83 #define realloc(x,z)   ((x) ? realloc(x,z) : malloc(z))
  84 #endif
  85
  86 char * _itoa(int n,char *str, int radix, int mod);
  87 char * _ltoa(int n,char *str, int radix, int mod);
  88
  89
  90 #ifdef _EiC
  91
  92 void (*_exit_FuNcN[32])(void);
  93 int _exit_FuNcS_n = 0;
  94
  95 void eic_exit(int);
  96
  97 int (atexit)(void f(void))
  98 {
  99     _exit_FuNcS_n;
 100     if(_exit_FuNcS_n == 32)
 101         return 1;
 102     _exit_FuNcN[_exit_FuNcS_n++]  = f;
 103     return 0;
 104 }
 105
 106 void (exit)(int status)
 107 {
 108     int i;
 109
 110     for(i=0;i<_exit_FuNcS_n;++i)
 111         (*_exit_FuNcN[i])();
 112     _exit_FuNcS_n = 0;
 113     eic_exit(status);
 114 }
 115
 116
 117
 118 /* sort and search functions that can't be builtin.
 119  * Functions copied from The Standard C Library
 120  * by P.J. Plauger
 121  */
 122
 123 #define _QS_BS_ 256
 124
 125 void (qsort)(void *_base, size_t _n, size_t _size,
 126              int (*_cmp)(const void *, const void *))
 127 {
 128 #ifndef _MEMCPY_
 129 #define _MEMCPY_
 130 void *memcpy(void * _dst, const void * _src, size_t _n);
 131 #endif
 132
 133     while(_n>1) {
 134         size_t _i = 0;
 135         size_t _j = _n - 1;
 136         char *_qi = (char*)_base;
 137         char *_qj = _qi + _size * _j;
 138         char * _qp = _qj;
 139
 140         while(_i<_j) {
 141             while(_i < _j && (*_cmp) (_qi, _qp) <= 0)
 142                 ++_i, _qi += _size;
 143             while(_i < _j && (*_cmp)(_qp, _qj) <= 0)
 144                 --_j, _qj -= _size;
 145             if(_i<_j) {
 146                 char _buf[_QS_BS_];
 147                 char * _q1 = _qi;
 148                 char * _q2 = _qj;
 149                 size_t _m, _ms;
 150                 for(_ms = _size; 0 < _ms; _ms -= _m, _q1 += _m,
 151                         _q2 -= _m) {
 152                     _m = _ms < _QS_BS_ ? _ms : _QS_BS_;
 153                     memcpy(_buf, _q1, _m);
 154                     memcpy(_q1, _q2, _m);
 155                     memcpy(_q2,_buf,_m);
 156                 }
 157                 ++_i, _qi += _size;
 158             }
 159         }
 160         if(_qi != _qp) {
 161             char _buf[_QS_BS_];
 162             char * _q1 = _qi;
 163             char * _q2 = _qp;
 164             size_t _m, _ms;
 165             for(_ms = _size; 0 < _ms; _ms -= _m, _q1 += _m,
 166                     _q2 -= _m) {
 167                 _m = _ms < _QS_BS_ ? _ms : _QS_BS_;
 168                 memcpy(_buf, _q1, _m);
 169                 memcpy(_q1, _q2, _m);
 170                 memcpy(_q2,_buf,_m);
 171
 172             }
 173         }
 174         _j = _n - _i - 1, _qi += _size;
 175         if(_j < _i) {
 176             if(1 < _j)
 177                 qsort(_qi,_j,_size,_cmp);
 178             _n = _i;
 179         } else {
 180             if(1 < _i)
 181                 qsort(_base,_i,_size,_cmp);
 182             _base = _qi;
 183             _n = _j;
 184         }
 185     }
 186 }
 187
 188 #undef _QS_BS_
 189
 190 void * (bsearch)(const void * _key, const void * _base,
 191                  size_t _nelem,
 192                  size_t _size,
 193                  int _cmp(const void * keyval, const void * datum))
 194 {
 195     const char *_p = _base;
 196     size_t _n;
 197     for(_n=_nelem;_n>0;) {
 198         const size_t _pivot = _n >> 1;
 199         const char *const _q = _p + _size * _pivot;
 200         const int _val = _cmp(_key,_q);
 201         if(_val < 0)
 202             _n = _pivot;
 203         else if(_val == 0)
 204             return (void*)_q;
 205         else {
 206             _p = _q + _size;
 207            _n -= _pivot + 1;
 208         }
 209     }
 210     return NULL;
 211 }
 212
 213
 214 #endif
 215
 216 #pragma pop_ptr
 217
 218 #endif /* _STDLIBH */
 219
 220
 221
 222
 223
 224
 225
 226