git.maemo.org Git - opencv/blob - apps/cvenv/EiC/stdClib/stdlib.c

   1 /* stdlib.c
   2  *
   3  *      (C) Copyright Apr 15 1995, Edmond J. Breen.
   4  *                 ALL RIGHTS RESERVED.
   5  * This code may be copied for personal, non-profit use only.
   6  *
   7  */
   8
   9
  10 #ifndef NO_STDLIB
  11
  12 #include <stdio.h>
  13 #include <stdarg.h>
  14 #include <stdlib.h>
  15 #include <signal.h>
  16 #include <string.h>
  17
  18 #include "eic.h"
  19
  20 #include "stdliblocal.h"
  21
  22 #include "xalloc.h"
  23
  24
  25 void EiC_Mod_Error(char * fmt, ...)
  26 {
  27     char buff[512];
  28     va_list args;
  29     va_start(args,fmt);
  30     sprintf(buff,fmt,args);
  31     EiC_messageDisplay(buff);
  32     va_end(args);
  33     raise(SIGSEGV);
  34 }
  35
  36 /*
  37    STDLIB.H  STUFF
  38    ----------------------------------*/
  39
  40 val_t eic_malloc(void)
  41 {
  42     val_t v;
  43
  44     v.p.sp = v.p.p = xmalloc(arg(0,getargs(),size_t));
  45     setEp( v.p, arg(0,getargs(),size_t) );
  46
  47     return v;
  48 }
  49
  50 val_t eic_calloc(void)
  51 {
  52     val_t v;
  53     arg_list ap = getargs();
  54     size_t s1,s2;
  55
  56     s1 = arg(0,ap,size_t);
  57     s2 = arg(1,ap,size_t);
  58
  59     v.p.sp = v.p.p = xcalloc(s1,s2);
  60
  61     setEp( v.p, s1 * s2 );
  62     return v;
  63 }
  64
  65 val_t eic_realloc(void)
  66 {
  67     val_t v;
  68     arg_list ap = getargs();
  69
  70     v.p.sp = v.p.p = xrealloc(arg(0,ap,ptr_t).p,
  71                               arg(1,ap,size_t));
  72     setEp( v.p, arg(1,ap,size_t) );
  73     return v;
  74 }
  75
  76 val_t eic_free(void)
  77 {
  78     val_t v;
  79
  80 #if 0
  81     ptr_t *p;
  82
  83
  84     p = arg(0,getargs(),ptr_t*);
  85
  86     xfree(p->p);
  87     p->p = p->sp = p->ep = NULL;
  88
  89 #else
  90
  91     ptr_t p;
  92     p = arg(0,getargs(),ptr_t);
  93
  94     xfree(p.p);
  95
  96 #endif
  97
  98     return v;
  99 }
 100
 101
 102 val_t eic_strtod(void)
 103 {
 104     val_t v;
 105     arg_list ap = getargs();
 106     ptr_t p1, *p2;
 107     void * endptr;
 108
 109     p1 = arg(0,ap,ptr_t);
 110
 111     if(arg(1,ap,ptr_t).p) {
 112         p2 = arg(1,ap,ptr_t).p;
 113         p2->sp = p1.sp;
 114         p2->ep = p1.ep;
 115         endptr= &p2->p;
 116     } else
 117         endptr = NULL;
 118
 119     v.dval = (float)strtod(p1.p,
 120                            endptr);
 121     return v;
 122 }
 123
 124 val_t eic_strtol(void)
 125 {
 126     val_t v;
 127     arg_list ap = getargs();
 128     ptr_t p1, *p2;
 129     void * endptr;
 130
 131     p1 = arg(0,ap,ptr_t);
 132
 133     if(arg(1,ap,ptr_t).p) {
 134         p2 = arg(1,ap,ptr_t).p;
 135         p2->sp = p1.sp;
 136         p2->ep = p1.ep;
 137         endptr= &p2->p;
 138     } else
 139         endptr = NULL;
 140
 141
 142     v.lval = strtol(p1.p,
 143                     endptr,
 144                     arg(2,ap,int));
 145     return v;
 146 }
 147
 148 val_t eic_strtoul(void)
 149 {
 150     val_t v;
 151     arg_list ap = getargs();
 152     ptr_t p1, *p2;
 153     void * endptr;
 154
 155     p1 = arg(0,ap,ptr_t);
 156
 157     if(arg(1,ap,ptr_t).p) {
 158         p2 = arg(1,ap,ptr_t).p;
 159         p2->sp = p1.sp;
 160         p2->ep = p1.ep;
 161         endptr= &p2->p;
 162     } else
 163         endptr = NULL;
 164
 165
 166     v.ulval = strtoul(p1.p,
 167                       endptr,
 168                       arg(2,ap,int));
 169     return v;
 170 }
 171
 172 #ifndef NO_SYSTEM
 173 val_t eic_system(void)
 174 {
 175     val_t v;
 176     v.ival = system(nextarg(getargs(),ptr_t).p);
 177     return v;
 178 }
 179 #endif
 180
 181
 182 val_t eic_itoa(void)
 183 {
 184     arg_list ap = getargs();
 185     val_t v;
 186
 187     getptrarg(1,v.p);
 188
 189     switch(arg(3,ap,int)) {
 190       case 1:
 191         v.p.sp = v.p.p = itoa(arg(0,ap,int),
 192                               v.p.p,
 193                               arg(2,ap,int));
 194         break;
 195       case 2:
 196         v.p.sp = v.p.p = utoa(arg(0,ap,unsigned),
 197                       v.p.p,
 198                       arg(2,ap,int));
 199     }
 200     setEp( v.p, strlen(v.p.p) + 1 );
 201
 202     return v;
 203 }
 204
 205 val_t eic_ltoa(void)
 206 {
 207     arg_list ap = getargs();
 208     val_t v;
 209
 210     getptrarg(1,v.p);
 211
 212     switch(arg(3,ap,int)) {
 213       case 1:
 214         v.p.sp = v.p.p = ltoa(arg(0,ap,long),
 215                       v.p.p,
 216                       arg(2,ap,int));
 217         break;
 218       case 2:
 219         v.p.sp = v.p.p = ultoa(arg(0,ap,unsigned long),
 220                        v.p.p,
 221                        arg(2,ap,int));
 222         break;
 223     }
 224
 225     setEp( v.p, strlen(v.p.p) + 1 );
 226
 227
 228     return  v;
 229 }
 230
 231 #if 0
 232 static unsigned long _Rseed = 1;
 233 int rand(void)
 234 {
 235     _Rseed = _Rseed * 1103515245 + 12345;
 236     return (unsigned)(_Rseed >> 16) & RAND_MAX;
 237 }
 238 void srand(unsigned int x)
 239 {
 240     _Rseed = x;
 241 }
 242
 243 #endif
 244
 245
 246 val_t eic_rand(void)
 247 {
 248     val_t v;
 249     v.ival = rand();
 250     return v;
 251 }
 252
 253
 254 val_t eic_srand(void)
 255 {
 256     val_t v;
 257     srand(nextarg(getargs(),unsigned int));
 258     return v;
 259 }
 260
 261 val_t eic_atoi(void)
 262 {
 263     val_t v;
 264     v.ival = atoi(nextarg(getargs(),ptr_t).p);
 265     return v;
 266 }
 267
 268 val_t eic_atol(void)
 269 {
 270     val_t v;
 271     v.lval = atol(nextarg(getargs(),ptr_t).p);
 272     return v;
 273 }
 274
 275 val_t eic_atof(void)
 276 {
 277     val_t v;
 278     v.dval = atof(nextarg(getargs(),ptr_t).p);
 279     return v;
 280 }
 281
 282
 283 #ifndef NO_ENV
 284 val_t eic_getenv(void)
 285 {
 286     val_t v;
 287     v.p.sp = v.p.p = getenv(nextarg(getargs(),ptr_t).p);
 288     if(v.p.p)
 289         setEp( v.p, strlen(v.p.p) + 1 );
 290     else
 291         v.p.ep = v.p.p;
 292     return v;
 293 }
 294
 295 val_t eic_putenv(void)
 296 {
 297     val_t v;
 298     v.ival = putenv(nextarg(getargs(),ptr_t).p);
 299     return v;
 300 }
 301 #endif
 302
 303 val_t eic_exit(void)
 304 {
 305     extern int EiC_interActive; /* defined in starteic.c */
 306     val_t v;
 307
 308     if(!EiC_interActive) {
 309         v.ival = arg(0,getargs(),int);
 310         exit(v.ival);
 311     }
 312 #ifdef WIN32
 313     raise(SIGTERM);
 314 #else
 315     raise(SIGUSR1);
 316 #endif
 317     return v;
 318 }
 319
 320 val_t eic_abort(void)
 321 {
 322     extern int EiC_interActive; /* defined in starteic.c */
 323     val_t v;
 324
 325     if(!EiC_interActive)
 326         abort();
 327
 328 #ifdef WIN32
 329         raise(SIGTERM);
 330 #else
 331     raise(SIGUSR1);
 332 #endif
 333     return v;
 334
 335 }
 336
 337
 338
 339 #endif
 340
 341 /****************************************************************/
 342
 343 void module_stdlib(void)
 344 {
 345
 346 #ifndef NO_STDLIB
 347
 348
 349     /* stdlib.h */
 350
 351     EiC_add_builtinfunc("system", eic_system);
 352     EiC_add_builtinfunc("_itoa", eic_itoa);
 353     EiC_add_builtinfunc("_ltoa", eic_ltoa);
 354     EiC_add_builtinfunc("malloc", eic_malloc);
 355     EiC_add_builtinfunc("calloc", eic_calloc);
 356     EiC_add_builtinfunc("realloc", eic_realloc);
 357     EiC_add_builtinfunc("free", eic_free);
 358     EiC_add_builtinfunc("strtod", eic_strtod);
 359     EiC_add_builtinfunc("strtol", eic_strtol);
 360     EiC_add_builtinfunc("strtoul", eic_strtoul);
 361     EiC_add_builtinfunc("rand", eic_rand);
 362     EiC_add_builtinfunc("srand", eic_srand);
 363     EiC_add_builtinfunc("atoi", eic_atoi);
 364     EiC_add_builtinfunc("atof", eic_atof);
 365     EiC_add_builtinfunc("atol", eic_atol);
 366
 367 #ifndef NO_ENV
 368
 369     EiC_add_builtinfunc("getenv", eic_getenv);
 370     EiC_add_builtinfunc("putenv", eic_putenv);
 371
 372 #endif
 373
 374     EiC_add_builtinfunc("abort",eic_abort);
 375     EiC_add_builtinfunc("eic_exit",eic_exit);
 376
 377 #endif
 378
 379 }
 380