/* 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 "m51cn128evb.h" | |
#include "stdlib.h" | |
#define TRUE 1 | |
#define FALSE 0 | |
#define NULL 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)); | |
} | |
/****************************************************************/ | |
unsigned long | |
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; | |
} | |
/****************************************************************/ | |
char * | |
strrchr(const char *s, int c) | |
{ | |
const char *last = NULL; | |
if (c == '\0') | |
return strchr(s, c); | |
while ((s = strchr(s, c)) != NULL) { | |
last = s; | |
s++; | |
} | |
return (char *) last; | |
} | |