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

   1 /* string.c
   2  *
   3  *      (C) Copyright Dec 20 1998, Edmond J. Breen.
   4  *                 ALL RIGHTS RESERVED.
   5  * This code may be copied for personal, non-profit use only.
   6  *
   7  */
   8 /* This file is broken into 2 parts
   9  * the first part defines the interface routines
  10  * and the 2nd part adds the interface routine
  11  * to EiC's look up tables.
  12  */
  13
  14
  15 #include <stdio.h>
  16 #include <string.h>
  17 #include <stdlib.h>
  18 #include <stdarg.h>
  19
  20
  21 #include "eic.h"
  22 #include "stdliblocal.h"
  23
  24 #include "xalloc.h"
  25
  26
  27 /*
  28    STRING.H STUFF
  29    ------------------------------*/
  30
  31
  32 val_t eic_memcpy(void)
  33 {
  34     val_t v;
  35     ptr_t  p2;
  36     size_t s;
  37
  38     getptrarg(0,v.p);
  39     getptrarg(1,p2);
  40
  41     s = arg(2,getargs(),size_t);
  42
  43     checkEp(v.p,s);
  44     checkEp(p2,s);
  45
  46     memcpy(v.p.p,p2.p,s);
  47
  48     return v;
  49 }
  50 val_t eic_memmove(void)
  51 {
  52     val_t v;
  53     ptr_t  p2;
  54     size_t s;
  55
  56     getptrarg(0,v.p);
  57     getptrarg(1,p2);
  58
  59     s = arg(2,getargs(),size_t);
  60
  61
  62     checkEp(v.p,s);
  63     checkEp(p2,s);
  64
  65
  66 #ifdef _SUNOS
  67     bcopy(p2.p,v.p.p,s);
  68 #else
  69     memmove(v.p.p,p2.p,s);
  70 #endif
  71     return v;
  72 }
  73 val_t eic_strcpy(void)     /* unsafe */
  74 {
  75     val_t v;
  76
  77     getptrarg(0,v.p);
  78     checkEp(v.p,strlen(arg(1,getargs(), ptr_t).p) + 1);
  79
  80     strcpy(v.p.p,
  81            arg(1,getargs(), ptr_t).p);
  82     return v;
  83 }
  84
  85 val_t eic_strdup(void)     /* unsafe */
  86 {
  87     val_t v;
  88
  89     char *p = arg(0,getargs(),ptr_t).p;
  90     int len = strlen(p);
  91     v.p.sp = v.p.p = xmalloc(len +1);
  92     if(v.p.p) {
  93         strcpy(v.p.p,p);
  94         v.p.ep = setEp(v.p, len);
  95     } else
  96         v.p.ep = NULL;
  97
  98     return v;
  99 }
 100
 101
 102 val_t eic_strncpy(void)
 103 {
 104     val_t v;
 105     ptr_t  p2;
 106     size_t s;
 107
 108     getptrarg(0,v.p);
 109     getptrarg(1,p2);
 110
 111     s = arg(2,getargs(),size_t);
 112
 113
 114     checkEp(v.p,s);
 115
 116     strncpy(v.p.p,p2.p,s);
 117
 118
 119     return v;
 120 }
 121 val_t eic_strcat(void)  /* unsafe */
 122 {
 123     val_t v;
 124     ptr_t  p2;
 125
 126     getptrarg(0,v.p);
 127     getptrarg(1,p2);
 128
 129     checkEp( v.p, strlen(v.p.p) + strlen(p2.p) + 1 );
 130
 131     strcat(v.p.p,p2.p);
 132     return v;
 133 }
 134
 135 val_t eic_strncat(void) /* unsafe */
 136 {
 137     val_t v;
 138     ptr_t  p2;
 139     size_t s, s1;
 140
 141     getptrarg(0,v.p);
 142     getptrarg(1,p2);
 143
 144     s = arg(2,getargs(),size_t);
 145     s1 = strlen(p2.p);
 146
 147     checkEp(v.p,strlen(v.p.p) + (s < s1 ? s : s1) + 1 );
 148
 149     strncat(v.p.p,p2.p,s);
 150
 151     return v;
 152 }
 153 val_t eic_memcmp(void)
 154 {
 155     val_t v;
 156     v.ival = memcmp(arg(0,getargs(),ptr_t).p,
 157                  arg(1,getargs(),ptr_t).p,
 158                  arg(2,getargs(),size_t));
 159     return v;
 160 }
 161 val_t eic_strcmp(void)
 162 {
 163     val_t v;
 164     v.ival  = strcmp(arg(0,getargs(),ptr_t).p,
 165                   arg(1,getargs(),ptr_t).p);
 166     return v;
 167 }
 168 val_t eic_strcoll(void)
 169 {
 170     val_t v;
 171     v.ival = strcoll(arg(0,getargs(),ptr_t).p,
 172                   arg(1,getargs(),ptr_t).p);
 173     return v;
 174 }
 175 val_t eic_strncmp(void)
 176 {
 177     val_t v;
 178     v.ival  = strncmp(arg(0,getargs(),ptr_t).p,
 179                    arg(1,getargs(),ptr_t).p,
 180                    arg(2,getargs(),size_t));
 181     return v;
 182 }
 183 val_t eic_strxfrm(void)
 184 {
 185     val_t v;
 186     v.szval = strxfrm(arg(0,getargs(),ptr_t).p,
 187                      arg(1,getargs(),ptr_t).p,
 188                      arg(2,getargs(),size_t));
 189     return v;
 190 }
 191 val_t eic_memchr(void)
 192 {
 193     val_t v;
 194
 195     v.p = arg(0,getargs(),ptr_t);
 196
 197     v.p.p = memchr(v.p.p,
 198                    arg(1,getargs(),int),
 199                    arg(2,getargs(),size_t));
 200     return v;
 201 }
 202 val_t eic_strchr(void)
 203 {
 204     val_t v;
 205     v.p = arg(0,getargs(),ptr_t);
 206     v.p.p = strchr(v.p.p,
 207            arg(1,getargs(),int));
 208     return v;
 209 }
 210 val_t eic_strcspn(void)
 211 {
 212     val_t v;
 213     v.szval = strcspn(arg(0,getargs(),ptr_t).p,
 214                      arg(1,getargs(),ptr_t).p);
 215     return v;
 216 }
 217 val_t eic_strpbrk(void)
 218 {
 219     val_t v;
 220
 221     getptrarg(0,v.p);
 222     v.p.p = strpbrk(v.p.p,
 223                     arg(1,getargs(),ptr_t).p);
 224     return v;
 225 }
 226 val_t eic_strrchr(void)
 227 {
 228     val_t v;
 229     getptrarg(0,v.p);
 230     v.p.p = strrchr(v.p.p,
 231                     arg(1,getargs(),int));
 232     return v;
 233 }
 234 val_t eic_strspn(void)
 235 {
 236     val_t v;
 237     v.szval = strspn(arg(0,getargs(),ptr_t).p,
 238                     arg(1,getargs(),ptr_t).p);
 239     return v;
 240 }
 241 val_t eic_strstr(void)
 242 {
 243     val_t v;
 244     getptrarg(0,v.p);
 245
 246     v.p.p = strstr(v.p.p,
 247                    arg(1,getargs(),ptr_t).p);
 248     return v;
 249 }
 250 val_t eic_strtok(void)
 251 {
 252     static val_t h;
 253     val_t v;
 254
 255     getptrarg(0,v.p);
 256
 257     if(v.p.p == NULL) {
 258         v.p.sp = h.p.sp;
 259         v.p.ep = h.p.ep;
 260     }else
 261         h.p = v.p;
 262
 263     v.p.p = strtok(v.p.p,
 264                    arg(1,getargs(),ptr_t).p);
 265     return v;
 266 }
 267 val_t eic_memset(void)
 268 {
 269     val_t v;
 270     size_t s;
 271
 272     getptrarg(0,v.p);
 273
 274     s = arg(2,getargs(),size_t);
 275     checkEp(v.p,s);
 276
 277     memset(v.p.p,
 278            arg(1,getargs(),int),
 279            s);
 280     return v;
 281 }
 282 val_t eic_strerror(void)
 283 {
 284     val_t v;
 285
 286     v.p.p = strerror(arg(0,getargs(),int));
 287
 288     v.p.sp = v.p.p;
 289
 290     setEp( v.p, strlen(v.p.p) + 1 );
 291
 292     return v;
 293 }
 294 val_t eic_strlen(void)
 295 {
 296     val_t v;
 297     v.szval = strlen(arg(0,getargs(),ptr_t).p);
 298     return v;
 299 }
 300
 301
 302 val_t eic_strrev(void)
 303 {
 304     val_t v;
 305     getptrarg(0,v.p);
 306     v.p.p = strrev(v.p.p);
 307     return  v;
 308 }
 309
 310 val_t eic_fftoa(void)
 311 {
 312     val_t v;
 313     arg_list ap = getargs();
 314
 315     getptrarg(1,v.p);
 316
 317     fftoa(arg(0,ap,float),   /* value */
 318           v.p.p,             /* string */
 319           arg(2,ap,int),     /* precision */
 320           arg(3,ap,char),    /* 'f','e' or 'E' */
 321           arg(4,ap,int));    /* truncation, i.e. 0 or 1 */
 322     return v;
 323 }
 324
 325
 326
 327 /********************************************************************/
 328
 329 void module_string(void)
 330 {
 331
 332     /* string .h */
 333     EiC_add_builtinfunc("memcpy",eic_memcpy);
 334     EiC_add_builtinfunc("memmove",eic_memmove);
 335     EiC_add_builtinfunc("strcpy",eic_strcpy);
 336     EiC_add_builtinfunc("strdup",eic_strdup);
 337     EiC_add_builtinfunc("strncpy",eic_strncpy);
 338     EiC_add_builtinfunc("strcat",eic_strcat);
 339     EiC_add_builtinfunc("strncat",eic_strncat);
 340     EiC_add_builtinfunc("memcmp",eic_memcmp);
 341     EiC_add_builtinfunc("strcmp",eic_strcmp);
 342     EiC_add_builtinfunc("strcoll",eic_strcoll);
 343     EiC_add_builtinfunc("strncmp",eic_strncmp);
 344     EiC_add_builtinfunc("strxfrm",eic_strxfrm);
 345     EiC_add_builtinfunc("memchr",eic_memchr);
 346     EiC_add_builtinfunc("strchr",eic_strchr);
 347     EiC_add_builtinfunc("strcspn",eic_strcspn);
 348     EiC_add_builtinfunc("strpbrk",eic_strpbrk);
 349     EiC_add_builtinfunc("strrchr",eic_strrchr);
 350     EiC_add_builtinfunc("strspn",eic_strspn);
 351     EiC_add_builtinfunc("strstr",eic_strstr);
 352     EiC_add_builtinfunc("strtok",eic_strtok);
 353     EiC_add_builtinfunc("memset",eic_memset);
 354     EiC_add_builtinfunc("strerror",eic_strerror);
 355     EiC_add_builtinfunc("strlen",eic_strlen);
 356
 357     EiC_add_builtinfunc("strrev", eic_strrev);
 358     EiC_add_builtinfunc("fftoa", eic_fftoa);
 359
 360 }