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