git.maemo.org Git - opencv/blob - apps/Hawk/CVEiCL/EiC/src/win32/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 char *getenv(const char *name);
  58
  59 void exit(int eval);
  60 int atexit(void f(void));
  61 void abort(void);
  62
  63 /* these two macros are unsafe */
  64 #define abs(x)     ((x)>0? (x):-(x))
  65 #define labs(x)    abs(x)
  66
  67 /* non-standard stuff EiC interpreter stuff*/
  68 #ifdef _EiC
  69 #define itoa(x,y,z)     _itoa(x,y,z,1)
  70 #define utoa(x,y,z)     _itoa(x,y,z,2)
  71 #define ltoa(x,y,z)     _ltoa(x,y,z,1)
  72 #define ultoa(x,y,z)    _ltoa(x,y,z,2)
  73 #else
  74 char *utoa(unsigned int n, char *s, int radix);
  75 char *itoa(int n, char *s, int radix);
  76 char *ultoa(unsigned long n, char *s, int radix);
  77 char *ltoa(long n, char *s, int radix);
  78 #endif /* end EiC */
  79
  80 #if defined(_SUNOS) && !defined(_EiC)
  81 #define realloc(x,z)   ((x) ? realloc(x,z) : malloc(z))
  82 #endif
  83
  84 char * _itoa(int n,char *str, int radix, int mod);
  85 char * _ltoa(int n,char *str, int radix, int mod);
  86
  87
  88 #ifdef _EiC
  89
  90 void (*_exit_FuNcN[32])(void);
  91 int _exit_FuNcS_n = 0;
  92
  93 void eic_exit(int);
  94
  95 int (atexit)(void f(void))
  96 {
  97     _exit_FuNcS_n;
  98     if(_exit_FuNcS_n == 32)
  99         return 1;
 100     _exit_FuNcN[_exit_FuNcS_n++]  = f;
 101     return 0;
 102 }
 103
 104 void (exit)(int status)
 105 {
 106     int i;
 107
 108     for(i=0;i<_exit_FuNcS_n;++i)
 109         (*_exit_FuNcN[i])();
 110     _exit_FuNcS_n = 0;
 111     eic_exit(status);
 112 }
 113
 114
 115
 116 /* sort and search functions that can't be builtin.
 117  * Functions copied from The Standard C Library
 118  * by P.J. Plauger
 119  */
 120
 121 #define _QS_BS_ 256
 122
 123 void (qsort)(void *_base, size_t _n, size_t _size,
 124              int (*_cmp)(const void *, const void *))
 125 {
 126 #ifndef _MEMCPY_
 127 #define _MEMCPY_
 128 void *memcpy(void * _dst, const void * _src, size_t _n);
 129 #endif
 130
 131     while(_n>1) {
 132         size_t _i = 0;
 133         size_t _j = _n - 1;
 134         char *_qi = (char*)_base;
 135         char *_qj = _qi + _size * _j;
 136         char * _qp = _qj;
 137
 138         while(_i<_j) {
 139             while(_i < _j && (*_cmp) (_qi, _qp) <= 0)
 140                 ++_i, _qi += _size;
 141             while(_i < _j && (*_cmp)(_qp, _qj) <= 0)
 142                 --_j, _qj -= _size;
 143             if(_i<_j) {
 144                 char _buf[_QS_BS_];
 145                 char * _q1 = _qi;
 146                 char * _q2 = _qj;
 147                 size_t _m, _ms;
 148                 for(_ms = _size; 0 < _ms; _ms -= _m, _q1 += _m,
 149                         _q2 -= _m) {
 150                     _m = _ms < _QS_BS_ ? _ms : _QS_BS_;
 151                     memcpy(_buf, _q1, _m);
 152                     memcpy(_q1, _q2, _m);
 153                     memcpy(_q2,_buf,_m);
 154                 }
 155                 ++_i, _qi += _size;
 156             }
 157         }
 158         if(_qi != _qp) {
 159             char _buf[_QS_BS_];
 160             char * _q1 = _qi;
 161             char * _q2 = _qp;
 162             size_t _m, _ms;
 163             for(_ms = _size; 0 < _ms; _ms -= _m, _q1 += _m,
 164                     _q2 -= _m) {
 165                 _m = _ms < _QS_BS_ ? _ms : _QS_BS_;
 166                 memcpy(_buf, _q1, _m);
 167                 memcpy(_q1, _q2, _m);
 168                 memcpy(_q2,_buf,_m);
 169
 170             }
 171         }
 172         _j = _n - _i - 1, _qi += _size;
 173         if(_j < _i) {
 174             if(1 < _j)
 175                 qsort(_qi,_j,_size,_cmp);
 176             _n = _i;
 177         } else {
 178             if(1 < _i)
 179                 qsort(_base,_i,_size,_cmp);
 180             _base = _qi;
 181             _n = _j;
 182         }
 183     }
 184 }
 185
 186 #undef _QS_BS_
 187
 188 void * (bsearch)(const void * _key, const void * _base,
 189                  size_t _nelem,
 190                  size_t _size,
 191                  int _cmp(const void * keyval, const void * datum))
 192 {
 193     const char *_p = _base;
 194     size_t _n;
 195     for(_n=_nelem;_n>0;) {
 196         const size_t _pivot = _n >> 1;
 197         const char *const _q = _p + _size * _pivot;
 198         const int _val = _cmp(_key,_q);
 199         if(_val < 0)
 200             _n = _pivot;
 201         else if(_val == 0)
 202             return (void*)_q;
 203         else {
 204             _p = _q + _size;
 205            _n -= _pivot + 1;
 206         }
 207     }
 208     return NULL;
 209 }
 210
 211
 212 #endif
 213
 214 #pragma pop_ptr
 215
 216 #endif /* _STDLIBH */
 217
 218
 219
 220
 221
 222
 223
 224