Add FreeRTOS-Plus directory.

FreeRTOS/Demo/ColdFire_MCF52221_CodeWarrior/sources/stdlib.c

@@ -0,0 +1,509 @@
+/* FILENAME: stdlib.c
+ *
+ * Functions normally found in a standard C lib.
+ *
+ * 12/28/2005 - added memcmp and memmove
+ *
+ * Notes: These functions support ASCII only!!!
+ */
+
+#include "support_common.h"
+#include "stdlib.h"
+
+/***********************************************************************/
+/*
+ * Misc. Defines
+ */
+#ifdef  FALSE
+#undef  FALSE
+#endif
+#define FALSE   (0)
+
+#ifdef  TRUE
+#undef  TRUE
+#endif
+#define TRUE    (1)
+
+#ifdef  NULL
+#undef  NULL
+#endif
+#define NULL    (0)
+
+#ifdef  ON
+#undef  ON
+#endif
+#define ON      (1)
+
+#ifdef  OFF
+#undef  OFF
+#endif
+#define OFF     (0)
+
+
+/****************************************************************/
+int
+isspace (int ch)
+{
+	if ((ch == ' ') || (ch == '\t'))	/* \n ??? */
+		return TRUE;
+	else
+		return FALSE;
+}
+
+/****************************************************************/
+int
+isalnum (int ch)
+{
+	/* ASCII only */
+	if (((ch >= '0') && (ch <= '9')) ||
+		((ch >= 'A') && (ch <= 'Z')) ||
+		((ch >= 'a') && (ch <= 'z')))
+		return TRUE;
+	else
+		return FALSE;
+}
+
+/****************************************************************/
+int
+isdigit (int ch)
+{
+	/* ASCII only */
+	if ((ch >= '0') && (ch <= '9'))
+		return TRUE;
+	else
+		return FALSE;
+}
+
+/****************************************************************/
+int
+isupper (int ch)
+{
+	/* ASCII only */
+	if ((ch >= 'A') && (ch <= 'Z'))
+		return TRUE;
+	else
+		return FALSE;
+}
+
+/****************************************************************/
+int
+strcasecmp (const char *s1, const char *s2)
+{
+	char	c1, c2;
+	int		result = 0;
+
+	while (result == 0)
+	{
+		c1 = *s1++;
+		c2 = *s2++;
+		if ((c1 >= 'a') && (c1 <= 'z'))
+			c1 = (char)(c1 - ' ');
+		if ((c2 >= 'a') && (c2 <= 'z'))
+			c2 = (char)(c2 - ' ');
+		if ((result = (c1 - c2)) != 0)
+			break;
+		if ((c1 == 0) || (c2 == 0))
+			break;
+	}
+	return result;
+}
+
+
+/****************************************************************/
+int
+stricmp (const char *s1, const char *s2)
+{
+   return (strcasecmp(s1, s2));
+}
+
+/****************************************************************/
+int
+strncasecmp (const char *s1, const char *s2, int n)
+{
+	char	c1, c2;
+	int		k = 0;
+	int		result = 0;
+
+	while ( k++ < n )
+	{
+		c1 = *s1++;
+		c2 = *s2++;
+		if ((c1 >= 'a') && (c1 <= 'z'))
+			c1 = (char)(c1 - ' ');
+		if ((c2 >= 'a') && (c2 <= 'z'))
+			c2 = (char)(c2 - ' ');
+		if ((result = (c1 - c2)) != 0)
+			break;
+		if ((c1 == 0) || (c2 == 0))
+			break;
+	}
+	return result;
+}
+
+/****************************************************************/
+int
+strnicmp (const char *s1, const char *s2, int n)
+{
+   return (strncasecmp(s1, s2, n));
+}
+
+/****************************************************************/
+uint32
+strtoul (char *str, char **ptr, int base)
+{
+   unsigned long rvalue = 0;
+   int neg = 0;
+   int c;
+
+   /* Validate parameters */
+   if ((str != NULL) && (base >= 0) && (base <= 36))
+   {
+      /* Skip leading white spaces */
+      while (isspace(*str))
+      {
+         ++str;
+	}
+
+	/* Check for notations */
+       switch (str[0])
+	{
+		case '0':
+          if (base == 0)
+          {
+             if ((str[1] == 'x') || (str[1] == 'X'))
+				{
+					base = 16;
+                str += 2;
+             }
+             else
+             {
+                base = 8;
+                str++;
+				}
+			}
+			break;
+    
+		case '-':
+			neg = 1;
+          str++;
+          break;
+
+       case '+':
+          str++;
+			break;
+
+		default:
+			break;
+	}
+
+	if (base == 0)
+		base = 10;
+
+      /* Valid "digits" are 0..9, A..Z, a..z */
+      while (isalnum(c = *str))
+      {
+		/* Convert char to num in 0..36 */
+         if ((c -= ('a' - 10)) < 10)         /* 'a'..'z' */
+         {
+            if ((c += ('a' - 'A')) < 10)     /* 'A'..'Z' */
+            {
+               c += ('A' - '0' - 10);        /* '0'..'9' */
+			}
+		}
+
+		/* check c against base */
+		if (c >= base)
+		{
+			break;
+		}
+
+		if (neg)
+		{
+			rvalue = (rvalue * base) - c;
+		}
+		else
+		{
+			rvalue = (rvalue * base) + c;
+         }
+
+         ++str;
+		}
+	}
+
+   /* Upon exit, 'str' points to the character at which valid info */
+   /* STOPS.  No chars including and beyond 'str' are used.        */
+
+	if (ptr != NULL)
+			*ptr = str;
+		
+		return rvalue;
+	}
+
+/****************************************************************/
+int
+atoi (const char *str)
+{
+   char *s = (char *)str;
+   
+   return ((int)strtoul(s, NULL, 10));
+}
+
+/****************************************************************/
+int
+strlen (const char *str)
+{
+	char *s = (char *)str;
+	int len = 0;
+
+	if (s == NULL)
+		return 0;
+
+	while (*s++ != '\0')
+		++len;
+
+	return len;
+}
+
+/****************************************************************/
+char *
+strcat (char *dest, const char *src)
+{
+	char *dp;
+	char *sp = (char *)src;
+
+	if ((dest != NULL) && (src != NULL))
+	{
+		dp = &dest[strlen(dest)];
+
+		while (*sp != '\0')
+		{
+			*dp++ = *sp++;
+		}
+		*dp = '\0';
+	}
+	return dest;
+}
+
+/****************************************************************/
+char *
+strncat (char *dest, const char *src, int n)
+{
+	char *dp;
+	char *sp = (char *)src;
+
+	if ((dest != NULL) && (src != NULL) && (n > 0))
+	{
+		dp = &dest[strlen(dest)];
+
+		while ((*sp != '\0') && (n-- > 0))
+		{
+			*dp++ = *sp++;
+		}
+		*dp = '\0';
+	}
+	return dest;
+}
+
+/****************************************************************/
+char *
+strcpy (char *dest, const char *src)
+{
+	char *dp = (char *)dest;
+	char *sp = (char *)src;
+
+	if ((dest != NULL) && (src != NULL))
+	{
+		while (*sp != '\0')
+		{
+			*dp++ = *sp++;
+		}
+		*dp = '\0';
+	}
+	return dest;
+}
+
+/****************************************************************/
+char *
+strncpy (char *dest, const char *src, int n)
+{
+	char *dp = (char *)dest;
+	char *sp = (char *)src;
+
+	if ((dest != NULL) && (src != NULL) && (n > 0))
+	{
+		while ((*sp != '\0') && (n-- > 0))
+		{
+			*dp++ = *sp++;
+		}
+		*dp = '\0';
+	}
+	return dest;
+}
+
+/****************************************************************/
+int
+strcmp (const char *s1, const char *s2)
+{
+	/* No checks for NULL */
+	char *s1p = (char *)s1;
+	char *s2p = (char *)s2;
+
+	while (*s2p != '\0')
+	{
+		if (*s1p != *s2p)
+			break;
+
+		++s1p;
+		++s2p;
+	}
+	return (*s1p - *s2p);
+}
+
+/****************************************************************/
+int
+strncmp (const char *s1, const char *s2, int n)
+{
+	/* No checks for NULL */
+	char *s1p = (char *)s1;
+	char *s2p = (char *)s2;
+
+	if (n <= 0)
+		return 0;
+
+	while (*s2p != '\0')
+	{
+		if (*s1p != *s2p)
+			break;
+
+		if (--n == 0)
+			break;
+
+		++s1p;
+		++s2p;
+	}
+	return (*s1p - *s2p);
+}
+
+/****************************************************************/
+char *
+strstr(const char *s1, const char *s2)
+{
+   char *sp = (char *)s1;
+   int  len1 = strlen(s1);
+   int  len2 = strlen(s2);
+
+   while (len1 >= len2) 
+   {
+      if (strncmp(sp, s2, len2) == 0)
+      {
+         return (sp);
+      }
+      ++sp;
+      --len1;
+   }
+
+   return (NULL);
+}
+
+/****************************************************************/
+char *
+strchr(const char *str, int c)
+{
+   char *sp = (char *)str;
+   char  ch = (char)(c & 0xff);
+
+   while (*sp != '\0')
+   {
+      if (*sp == ch)
+      {
+         return (sp);
+      }
+      ++sp;
+   }
+
+   return (NULL);
+}
+
+/****************************************************************/
+void *
+memcpy (void *dest, const void *src, unsigned n)
+{
+	unsigned char *dbp = (unsigned char *)dest;
+	unsigned char *sbp = (unsigned char *)src;
+
+	if ((dest != NULL) && (src != NULL) && (n > 0))
+	{
+      while (n--)
+			*dbp++ = *sbp++;
+	}
+	return dest;
+}
+
+/****************************************************************/
+void *
+memset (void *s, int c, unsigned n)
+{
+	/* Not optimized, but very portable */
+	unsigned char *sp = (unsigned char *)s;
+
+	if ((s != NULL) && (n > 0))
+	{
+		while (n--)
+		{
+			*sp++ = (unsigned char)c;
+		}
+	}
+	return s;
+}
+
+/****************************************************************/
+int
+memcmp (const void *s1, const void *s2, unsigned n)
+{
+   unsigned char *s1p, *s2p;
+
+   if (s1 && s2 && (n > 0))
+   {
+      s1p = (unsigned char *)s1;
+      s2p = (unsigned char *)s2;
+
+      while ((--n >= 0) && (*s1p == *s2p))
+      {
+         if (*s1p != *s2p)
+            return (*s1p - *s2p);
+         ++s1p;
+         ++s2p;
+      }
+   }
+
+   return (0);
+}
+
+/****************************************************************/
+void *
+memmove (void *dest, const void *src, unsigned n)
+{
+   unsigned char *dbp = (unsigned char *)dest;
+   unsigned char *sbp = (unsigned char *)src;
+   unsigned char *dend = dbp + n;
+   unsigned char *send = sbp + n;
+
+   if ((dest != NULL) && (src != NULL) && (n > 0))
+   {
+      /* see if a memcpy would overwrite source buffer */
+      if ((sbp < dbp) && (dbp < send))
+      {
+         while (n--)
+            *(--dend) = *(--send);
+      }
+      else
+      {
+         while (n--)
+            *dbp++ = *sbp++;
+      }
+   }
+
+   return dest;
+}
+
+/****************************************************************/