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