begriffs open source - cmsis-freertos/blob - Demo/ColdFire_MCF51CN128_CodeWarrior/Sources/stdlib.c

   1 /* FILENAME: stdlib.c
   2  *
   3  * Functions normally found in a standard C lib.
   4  *
   5  * 12/28/2005 - added memcmp and memmove
   6  *
   7  * Notes: These functions support ASCII only!!!
   8  */
   9
  10 //#include "m51cn128evb.h"
  11 #include "stdlib.h"
  12
  13 #define TRUE 1
  14 #define FALSE 0
  15 #define NULL 0
  16
  17 /****************************************************************/
  18 int
  19 isspace (int ch)
  20 {
  21         if ((ch == ' ') || (ch == '\t'))        /* \n ??? */
  22                 return TRUE;
  23         else
  24                 return FALSE;
  25 }
  26
  27 /****************************************************************/
  28 int
  29 isalnum (int ch)
  30 {
  31         /* ASCII only */
  32         if (((ch >= '0') && (ch <= '9')) ||
  33                 ((ch >= 'A') && (ch <= 'Z')) ||
  34                 ((ch >= 'a') && (ch <= 'z')))
  35                 return TRUE;
  36         else
  37                 return FALSE;
  38 }
  39
  40 /****************************************************************/
  41 int
  42 isdigit (int ch)
  43 {
  44         /* ASCII only */
  45         if ((ch >= '0') && (ch <= '9'))
  46                 return TRUE;
  47         else
  48                 return FALSE;
  49 }
  50
  51 /****************************************************************/
  52 int
  53 isupper (int ch)
  54 {
  55         /* ASCII only */
  56         if ((ch >= 'A') && (ch <= 'Z'))
  57                 return TRUE;
  58         else
  59                 return FALSE;
  60 }
  61
  62 /****************************************************************/
  63 int
  64 strcasecmp (const char *s1, const char *s2)
  65 {
  66         char    c1, c2;
  67         int             result = 0;
  68
  69         while (result == 0)
  70         {
  71                 c1 = *s1++;
  72                 c2 = *s2++;
  73                 if ((c1 >= 'a') && (c1 <= 'z'))
  74                         c1 = (char)(c1 - ' ');
  75                 if ((c2 >= 'a') && (c2 <= 'z'))
  76                         c2 = (char)(c2 - ' ');
  77                 if ((result = (c1 - c2)) != 0)
  78                         break;
  79                 if ((c1 == 0) || (c2 == 0))
  80                         break;
  81         }
  82         return result;
  83 }
  84
  85
  86 /****************************************************************/
  87 int
  88 stricmp (const char *s1, const char *s2)
  89 {
  90    return (strcasecmp(s1, s2));
  91 }
  92
  93 /****************************************************************/
  94 int
  95 strncasecmp (const char *s1, const char *s2, int n)
  96 {
  97         char    c1, c2;
  98         int             k = 0;
  99         int             result = 0;
 100
 101         while ( k++ < n )
 102         {
 103                 c1 = *s1++;
 104                 c2 = *s2++;
 105                 if ((c1 >= 'a') && (c1 <= 'z'))
 106                         c1 = (char)(c1 - ' ');
 107                 if ((c2 >= 'a') && (c2 <= 'z'))
 108                         c2 = (char)(c2 - ' ');
 109                 if ((result = (c1 - c2)) != 0)
 110                         break;
 111                 if ((c1 == 0) || (c2 == 0))
 112                         break;
 113         }
 114         return result;
 115 }
 116
 117 /****************************************************************/
 118 int
 119 strnicmp (const char *s1, const char *s2, int n)
 120 {
 121    return (strncasecmp(s1, s2, n));
 122 }
 123
 124 /****************************************************************/
 125 unsigned long
 126 strtoul (char *str, char **ptr, int base)
 127 {
 128    unsigned long rvalue = 0;
 129    int neg = 0;
 130    int c;
 131
 132    /* Validate parameters */
 133    if ((str != NULL) && (base >= 0) && (base <= 36))
 134    {
 135       /* Skip leading white spaces */
 136       while (isspace(*str))
 137       {
 138          ++str;
 139         }
 140
 141         /* Check for notations */
 142        switch (str[0])
 143         {
 144                 case '0':
 145           if (base == 0)
 146           {
 147              if ((str[1] == 'x') || (str[1] == 'X'))
 148                                 {
 149                                         base = 16;
 150                 str += 2;
 151              }
 152              else
 153              {
 154                 base = 8;
 155                 str++;
 156                                 }
 157                         }
 158                         break;
 159
 160                 case '-':
 161                         neg = 1;
 162           str++;
 163           break;
 164
 165        case '+':
 166           str++;
 167                         break;
 168
 169                 default:
 170                         break;
 171         }
 172
 173         if (base == 0)
 174                 base = 10;
 175
 176       /* Valid "digits" are 0..9, A..Z, a..z */
 177       while (isalnum(c = *str))
 178       {
 179                 /* Convert char to num in 0..36 */
 180          if ((c -= ('a' - 10)) < 10)         /* 'a'..'z' */
 181          {
 182             if ((c += ('a' - 'A')) < 10)     /* 'A'..'Z' */
 183             {
 184                c += ('A' - '0' - 10);        /* '0'..'9' */
 185                         }
 186                 }
 187
 188                 /* check c against base */
 189                 if (c >= base)
 190                 {
 191                         break;
 192                 }
 193
 194                 if (neg)
 195                 {
 196                         rvalue = (rvalue * base) - c;
 197                 }
 198                 else
 199                 {
 200                         rvalue = (rvalue * base) + c;
 201          }
 202
 203          ++str;
 204                 }
 205         }
 206
 207    /* Upon exit, 'str' points to the character at which valid info */
 208    /* STOPS.  No chars including and beyond 'str' are used.        */
 209
 210         if (ptr != NULL)
 211                         *ptr = str;
 212
 213                 return rvalue;
 214         }
 215
 216 /****************************************************************/
 217 int
 218 atoi (const char *str)
 219 {
 220    char *s = (char *)str;
 221
 222    return ((int)strtoul(s, NULL, 10));
 223 }
 224
 225 /****************************************************************/
 226 int
 227 strlen (const char *str)
 228 {
 229         char *s = (char *)str;
 230         int len = 0;
 231
 232         if (s == NULL)
 233                 return 0;
 234
 235         while (*s++ != '\0')
 236                 ++len;
 237
 238         return len;
 239 }
 240
 241 /****************************************************************/
 242 char *
 243 strcat (char *dest, const char *src)
 244 {
 245         char *dp;
 246         char *sp = (char *)src;
 247
 248         if ((dest != NULL) && (src != NULL))
 249         {
 250                 dp = &dest[strlen(dest)];
 251
 252                 while (*sp != '\0')
 253                 {
 254                         *dp++ = *sp++;
 255                 }
 256                 *dp = '\0';
 257         }
 258         return dest;
 259 }
 260
 261 /****************************************************************/
 262 char *
 263 strncat (char *dest, const char *src, int n)
 264 {
 265         char *dp;
 266         char *sp = (char *)src;
 267
 268         if ((dest != NULL) && (src != NULL) && (n > 0))
 269         {
 270                 dp = &dest[strlen(dest)];
 271
 272                 while ((*sp != '\0') && (n-- > 0))
 273                 {
 274                         *dp++ = *sp++;
 275                 }
 276                 *dp = '\0';
 277         }
 278         return dest;
 279 }
 280
 281 /****************************************************************/
 282 char *
 283 strcpy (char *dest, const char *src)
 284 {
 285         char *dp = (char *)dest;
 286         char *sp = (char *)src;
 287
 288         if ((dest != NULL) && (src != NULL))
 289         {
 290                 while (*sp != '\0')
 291                 {
 292                         *dp++ = *sp++;
 293                 }
 294                 *dp = '\0';
 295         }
 296         return dest;
 297 }
 298
 299 /****************************************************************/
 300 char *
 301 strncpy (char *dest, const char *src, int n)
 302 {
 303         char *dp = (char *)dest;
 304         char *sp = (char *)src;
 305
 306         if ((dest != NULL) && (src != NULL) && (n > 0))
 307         {
 308                 while ((*sp != '\0') && (n-- > 0))
 309                 {
 310                         *dp++ = *sp++;
 311                 }
 312                 *dp = '\0';
 313         }
 314         return dest;
 315 }
 316
 317 /****************************************************************/
 318 int
 319 strcmp (const char *s1, const char *s2)
 320 {
 321         /* No checks for NULL */
 322         char *s1p = (char *)s1;
 323         char *s2p = (char *)s2;
 324
 325         while (*s2p != '\0')
 326         {
 327                 if (*s1p != *s2p)
 328                         break;
 329
 330                 ++s1p;
 331                 ++s2p;
 332         }
 333         return (*s1p - *s2p);
 334 }
 335
 336 /****************************************************************/
 337 int
 338 strncmp (const char *s1, const char *s2, int n)
 339 {
 340         /* No checks for NULL */
 341         char *s1p = (char *)s1;
 342         char *s2p = (char *)s2;
 343
 344         if (n <= 0)
 345                 return 0;
 346
 347         while (*s2p != '\0')
 348         {
 349                 if (*s1p != *s2p)
 350                         break;
 351
 352                 if (--n == 0)
 353                         break;
 354
 355                 ++s1p;
 356                 ++s2p;
 357         }
 358         return (*s1p - *s2p);
 359 }
 360
 361 /****************************************************************/
 362 char *
 363 strstr(const char *s1, const char *s2)
 364 {
 365    char *sp = (char *)s1;
 366    int  len1 = strlen(s1);
 367    int  len2 = strlen(s2);
 368
 369    while (len1 >= len2)
 370    {
 371       if (strncmp(sp, s2, len2) == 0)
 372       {
 373          return (sp);
 374       }
 375       ++sp;
 376       --len1;
 377    }
 378
 379    return (NULL);
 380 }
 381
 382 /****************************************************************/
 383 char *
 384 strchr(const char *str, int c)
 385 {
 386    char *sp = (char *)str;
 387    char  ch = (char)(c & 0xff);
 388
 389    while (*sp != '\0')
 390    {
 391       if (*sp == ch)
 392       {
 393          return (sp);
 394       }
 395       ++sp;
 396    }
 397
 398    return (NULL);
 399 }
 400
 401 /****************************************************************/
 402 void *
 403 memcpy (void *dest, const void *src, unsigned n)
 404 {
 405         unsigned char *dbp = (unsigned char *)dest;
 406         unsigned char *sbp = (unsigned char *)src;
 407
 408         if ((dest != NULL) && (src != NULL) && (n > 0))
 409         {
 410       while (n--)
 411                         *dbp++ = *sbp++;
 412         }
 413         return dest;
 414 }
 415
 416 /****************************************************************/
 417 void *
 418 memset (void *s, int c, unsigned n)
 419 {
 420         /* Not optimized, but very portable */
 421         unsigned char *sp = (unsigned char *)s;
 422
 423         if ((s != NULL) && (n > 0))
 424         {
 425                 while (n--)
 426                 {
 427                         *sp++ = (unsigned char)c;
 428                 }
 429         }
 430         return s;
 431 }
 432
 433 /****************************************************************/
 434 int
 435 memcmp (const void *s1, const void *s2, unsigned n)
 436 {
 437    unsigned char *s1p, *s2p;
 438
 439    if (s1 && s2 && (n > 0))
 440    {
 441       s1p = (unsigned char *)s1;
 442       s2p = (unsigned char *)s2;
 443
 444       while ((--n >= 0) && (*s1p == *s2p))
 445       {
 446          if (*s1p != *s2p)
 447             return (*s1p - *s2p);
 448          ++s1p;
 449          ++s2p;
 450       }
 451    }
 452
 453    return (0);
 454 }
 455
 456 /****************************************************************/
 457 void *
 458 memmove (void *dest, const void *src, unsigned n)
 459 {
 460    unsigned char *dbp = (unsigned char *)dest;
 461    unsigned char *sbp = (unsigned char *)src;
 462    unsigned char *dend = dbp + n;
 463    unsigned char *send = sbp + n;
 464
 465    if ((dest != NULL) && (src != NULL) && (n > 0))
 466    {
 467       /* see if a memcpy would overwrite source buffer */
 468       if ((sbp < dbp) && (dbp < send))
 469       {
 470          while (n--)
 471             *(--dend) = *(--send);
 472       }
 473       else
 474       {
 475          while (n--)
 476             *dbp++ = *sbp++;
 477       }
 478    }
 479
 480    return dest;
 481 }
 482
 483 /****************************************************************/
 484
 485 char *
 486 strrchr(const char *s, int c)
 487 {
 488     const char *last = NULL;
 489     if (c == '\0')
 490         return strchr(s, c);
 491     while ((s = strchr(s, c)) != NULL) {
 492         last = s;
 493         s++;
 494     }
 495     return (char *) last;
 496 }
 497