git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/ColdFire_MCF51CN128_CodeWarrior/Sources/stdlib.c

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