/*--------------------------------------------------------------------
|
/*--------------------------------------------------------------------
|
* TITLE: ANSI C Library
|
* TITLE: ANSI C Library
|
* AUTHOR: Steve Rhoads (rhoadss@yahoo.com)
|
* AUTHOR: Steve Rhoads (rhoadss@yahoo.com)
|
* DATE CREATED: 12/17/05
|
* DATE CREATED: 12/17/05
|
* FILENAME: libc.c
|
* FILENAME: libc.c
|
* PROJECT: Plasma CPU core
|
* PROJECT: Plasma CPU core
|
* COPYRIGHT: Software placed into the public domain by the author.
|
* COPYRIGHT: Software placed into the public domain by the author.
|
* Software 'as is' without warranty. Author liable for nothing.
|
* Software 'as is' without warranty. Author liable for nothing.
|
* DESCRIPTION:
|
* DESCRIPTION:
|
* Subset of the ANSI C library
|
* Subset of the ANSI C library
|
*--------------------------------------------------------------------*/
|
*--------------------------------------------------------------------*/
|
#define NO_ELLIPSIS
|
#define NO_ELLIPSIS
|
#include "rtos.h"
|
#include "rtos.h"
|
|
|
char *strcpy(char *dst, const char *src)
|
char *strcpy(char *dst, const char *src)
|
{
|
{
|
char *dstSave=dst;
|
char *dstSave=dst;
|
int c;
|
int c;
|
do
|
do
|
{
|
{
|
c = *dst++ = *src++;
|
c = *dst++ = *src++;
|
} while(c);
|
} while(c);
|
return dstSave;
|
return dstSave;
|
}
|
}
|
|
|
|
|
char *strncpy(char *dst, const char *src, int count)
|
char *strncpy(char *dst, const char *src, int count)
|
{
|
{
|
int c=1;
|
int c=1;
|
char *dstSave=dst;
|
char *dstSave=dst;
|
while(count-- > 0 && c)
|
while(count-- > 0 && c)
|
c = *dst++ = *src++;
|
c = *dst++ = *src++;
|
*dst = 0;
|
*dst = 0;
|
return dstSave;
|
return dstSave;
|
}
|
}
|
|
|
|
|
char *strcat(char *dst, const char *src)
|
char *strcat(char *dst, const char *src)
|
{
|
{
|
int c;
|
int c;
|
char *dstSave=dst;
|
char *dstSave=dst;
|
while(*dst)
|
while(*dst)
|
++dst;
|
++dst;
|
do
|
do
|
{
|
{
|
c = *dst++ = *src++;
|
c = *dst++ = *src++;
|
} while(c);
|
} while(c);
|
return dstSave;
|
return dstSave;
|
}
|
}
|
|
|
|
|
char *strncat(char *dst, const char *src, int count)
|
char *strncat(char *dst, const char *src, int count)
|
{
|
{
|
int c=1;
|
int c=1;
|
char *dstSave=dst;
|
char *dstSave=dst;
|
while(*dst)
|
while(*dst)
|
++dst;
|
++dst;
|
while(--count >= 0 && c)
|
while(--count >= 0 && c)
|
c = *dst++ = *src++;
|
c = *dst++ = *src++;
|
*dst = 0;
|
*dst = 0;
|
return dstSave;
|
return dstSave;
|
}
|
}
|
|
|
|
#ifdef STRNCAT_SIZE
|
|
char *strncat_size(char *dst, const char *src, int sizeDst)
|
|
{
|
|
int c=1;
|
|
char *dstSave=dst;
|
|
while(*dst)
|
|
++dst;
|
|
sizeDst -= dst - dstSave;
|
|
while(--sizeDst > 0 && c)
|
|
c = *dst++ = *src++;
|
|
*dst = 0;
|
|
return dstSave;
|
|
}
|
|
#endif
|
|
|
int strcmp(const char *string1, const char *string2)
|
int strcmp(const char *string1, const char *string2)
|
{
|
{
|
int diff, c;
|
int diff, c;
|
for(;;)
|
for(;;)
|
{
|
{
|
diff = *string1++ - (c = *string2++);
|
diff = *string1++ - (c = *string2++);
|
if(diff)
|
if(diff)
|
return diff;
|
return diff;
|
if(c == 0)
|
if(c == 0)
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
|
|
int strncmp(const char *string1, const char *string2, int count)
|
int strncmp(const char *string1, const char *string2, int count)
|
{
|
{
|
int diff, c;
|
int diff, c;
|
while(count-- > 0)
|
while(count-- > 0)
|
{
|
{
|
diff = *string1++ - (c = *string2++);
|
diff = *string1++ - (c = *string2++);
|
if(diff)
|
if(diff)
|
return diff;
|
return diff;
|
if(c == 0)
|
if(c == 0)
|
return 0;
|
return 0;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
char *strstr(const char *string, const char *find)
|
char *strstr(const char *string, const char *find)
|
{
|
{
|
int i;
|
int i;
|
for(;;)
|
for(;;)
|
{
|
{
|
for(i = 0; string[i] == find[i] && find[i]; ++i) ;
|
for(i = 0; string[i] == find[i] && find[i]; ++i) ;
|
if(find[i] == 0)
|
if(find[i] == 0)
|
return (char*)string;
|
return (char*)string;
|
if(*string++ == 0)
|
if(*string++ == 0)
|
return NULL;
|
return NULL;
|
}
|
}
|
}
|
}
|
|
|
|
|
int strlen(const char *string)
|
int strlen(const char *string)
|
{
|
{
|
const char *base=string;
|
const char *base=string;
|
while(*string++) ;
|
while(*string++) ;
|
return string - base - 1;
|
return string - base - 1;
|
}
|
}
|
|
|
|
|
void *memcpy(void *dst, const void *src, unsigned long bytes)
|
void *memcpy(void *dst, const void *src, unsigned long bytes)
|
{
|
{
|
if(((uint32)dst | (uint32)src | bytes) & 3)
|
if(((uint32)dst | (uint32)src | bytes) & 3)
|
{
|
{
|
uint8 *Dst = (uint8*)dst, *Src = (uint8*)src;
|
uint8 *Dst = (uint8*)dst, *Src = (uint8*)src;
|
while((int)bytes-- > 0)
|
while((int)bytes-- > 0)
|
*Dst++ = *Src++;
|
*Dst++ = *Src++;
|
}
|
}
|
else
|
else
|
{
|
{
|
uint32 *Dst32 = (uint32*)dst, *Src32 = (uint32*)src;
|
uint32 *Dst32 = (uint32*)dst, *Src32 = (uint32*)src;
|
bytes >>= 2;
|
bytes >>= 2;
|
while((int)bytes-- > 0)
|
while((int)bytes-- > 0)
|
*Dst32++ = *Src32++;
|
*Dst32++ = *Src32++;
|
}
|
}
|
return dst;
|
return dst;
|
}
|
}
|
|
|
|
|
void *memmove(void *dst, const void *src, unsigned long bytes)
|
void *memmove(void *dst, const void *src, unsigned long bytes)
|
{
|
{
|
uint8 *Dst = (uint8*)dst;
|
uint8 *Dst = (uint8*)dst;
|
uint8 *Src = (uint8*)src;
|
uint8 *Src = (uint8*)src;
|
if(Dst < Src)
|
if(Dst < Src)
|
{
|
{
|
while((int)bytes-- > 0)
|
while((int)bytes-- > 0)
|
*Dst++ = *Src++;
|
*Dst++ = *Src++;
|
}
|
}
|
else
|
else
|
{
|
{
|
Dst += bytes;
|
Dst += bytes;
|
Src += bytes;
|
Src += bytes;
|
while((int)bytes-- > 0)
|
while((int)bytes-- > 0)
|
*--Dst = *--Src;
|
*--Dst = *--Src;
|
}
|
}
|
return dst;
|
return dst;
|
}
|
}
|
|
|
|
|
int memcmp(const void *cs, const void *ct, unsigned long bytes)
|
int memcmp(const void *cs, const void *ct, unsigned long bytes)
|
{
|
{
|
uint8 *Dst = (uint8*)cs;
|
uint8 *Dst = (uint8*)cs;
|
uint8 *Src = (uint8*)ct;
|
uint8 *Src = (uint8*)ct;
|
int diff;
|
int diff;
|
while((int)bytes-- > 0)
|
while((int)bytes-- > 0)
|
{
|
{
|
diff = *Dst++ - *Src++;
|
diff = *Dst++ - *Src++;
|
if(diff)
|
if(diff)
|
return diff;
|
return diff;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
void *memset(void *dst, int c, unsigned long bytes)
|
void *memset(void *dst, int c, unsigned long bytes)
|
{
|
{
|
uint8 *Dst = (uint8*)dst;
|
uint8 *Dst = (uint8*)dst;
|
while((int)bytes-- > 0)
|
while((int)bytes-- > 0)
|
*Dst++ = (uint8)c;
|
*Dst++ = (uint8)c;
|
return dst;
|
return dst;
|
}
|
}
|
|
|
|
|
int abs(int n)
|
int abs(int n)
|
{
|
{
|
return n>=0 ? n : -n;
|
return n>=0 ? n : -n;
|
}
|
}
|
|
|
|
|
static uint32 Rand1=0x1f2bcda3;
|
static uint32 Rand1=0x1f2bcda3;
|
unsigned int rand(void)
|
int rand(void)
|
{
|
{
|
Rand1 = 1664525 * Rand1 + 1013904223; //from D.E. Knuth and H.W. Lewis
|
Rand1 = 1664525 * Rand1 + 1013904223; //from D.E. Knuth and H.W. Lewis
|
return Rand1 << 16 | Rand1 >> 16;
|
return Rand1 << 16 | Rand1 >> 16;
|
}
|
}
|
|
|
|
|
void srand(unsigned int seed)
|
void srand(unsigned int seed)
|
{
|
{
|
Rand1 = seed;
|
Rand1 = seed;
|
}
|
}
|
|
|
|
|
long strtol(const char *s, char **end, int base)
|
long strtol(const char *s, char **end, int base)
|
{
|
{
|
int i;
|
int i;
|
unsigned long ch, value=0, neg=0;
|
unsigned long ch, value=0, neg=0;
|
|
|
if(s[0] == '-')
|
if(s[0] == '-')
|
{
|
{
|
neg = 1;
|
neg = 1;
|
++s;
|
++s;
|
}
|
}
|
if(s[0] == '0' && s[1] == 'x')
|
if(s[0] == '0' && s[1] == 'x')
|
{
|
{
|
base = 16;
|
base = 16;
|
s += 2;
|
s += 2;
|
}
|
}
|
for(i = 0; i <= 8; ++i)
|
for(i = 0; i <= 8; ++i)
|
{
|
{
|
ch = *s++;
|
ch = *s++;
|
if('0' <= ch && ch <= '9')
|
if('0' <= ch && ch <= '9')
|
ch -= '0';
|
ch -= '0';
|
else if('A' <= ch && ch < base - 10 + 'A')
|
else if('A' <= ch && ch < base - 10 + 'A')
|
ch = ch - 'A' + 10;
|
ch = ch - 'A' + 10;
|
else if('a' <= ch && ch < base - 10 + 'a')
|
else if('a' <= ch && ch < base - 10 + 'a')
|
ch = ch - 'a' + 10;
|
ch = ch - 'a' + 10;
|
else
|
else
|
break;
|
break;
|
value = value * base + ch;
|
value = value * base + ch;
|
}
|
}
|
if(end)
|
if(end)
|
*end = (char*)s - 1;
|
*end = (char*)s - 1;
|
if(neg)
|
if(neg)
|
value = -(int)value;
|
value = -(int)value;
|
return value;
|
return value;
|
}
|
}
|
|
|
|
|
int atoi(const char *s)
|
int atoi(const char *s)
|
{
|
{
|
return strtol(s, NULL, 10);
|
return strtol(s, NULL, 10);
|
}
|
}
|
|
|
|
|
char *itoa(int num, char *dst, int base)
|
char *itoa(int num, char *dst, int base)
|
{
|
{
|
int digit, negate=0, place;
|
int digit, negate=0, place;
|
char c, text[20];
|
char c, text[20];
|
|
|
if(base == 10 && num < 0)
|
if(base == 10 && num < 0)
|
{
|
{
|
num = -num;
|
num = -num;
|
negate = 1;
|
negate = 1;
|
}
|
}
|
text[16] = 0;
|
text[16] = 0;
|
for(place = 15; place > 0; --place)
|
for(place = 15; place > 0; --place)
|
{
|
{
|
digit = (unsigned int)num % (unsigned int)base;
|
digit = (unsigned int)num % (unsigned int)base;
|
if(num == 0 && place < 15 && base == 10 && negate)
|
if(num == 0 && place < 15 && base == 10 && negate)
|
{
|
{
|
c = '-';
|
c = '-';
|
negate = 0;
|
negate = 0;
|
}
|
}
|
else if(digit < 10)
|
else if(digit < 10)
|
c = (char)('0' + digit);
|
c = (char)('0' + digit);
|
else
|
else
|
c = (char)('a' + digit - 10);
|
c = (char)('a' + digit - 10);
|
text[place] = c;
|
text[place] = c;
|
num = (unsigned int)num / (unsigned int)base;
|
num = (unsigned int)num / (unsigned int)base;
|
if(num == 0 && negate == 0)
|
if(num == 0 && negate == 0)
|
break;
|
break;
|
}
|
}
|
strcpy(dst, text + place);
|
strcpy(dst, text + place);
|
return dst;
|
return dst;
|
}
|
}
|
|
|
|
|
int sprintf(char *s, const char *format,
|
int sprintf(char *s, const char *format,
|
int arg0, int arg1, int arg2, int arg3,
|
int arg0, int arg1, int arg2, int arg3,
|
int arg4, int arg5, int arg6, int arg7)
|
int arg4, int arg5, int arg6, int arg7)
|
{
|
{
|
int argv[8];
|
int argv[8];
|
int argc=0, width, length;
|
int argc=0, width, length;
|
char f=0, prev, text[20], fill;
|
char f=0, prev, text[20], fill;
|
|
|
argv[0] = arg0; argv[1] = arg1; argv[2] = arg2; argv[3] = arg3;
|
argv[0] = arg0; argv[1] = arg1; argv[2] = arg2; argv[3] = arg3;
|
argv[4] = arg4; argv[5] = arg5; argv[6] = arg6; argv[7] = arg7;
|
argv[4] = arg4; argv[5] = arg5; argv[6] = arg6; argv[7] = arg7;
|
|
|
for(;;)
|
for(;;)
|
{
|
{
|
prev = f;
|
prev = f;
|
f = *format++;
|
f = *format++;
|
if(f == 0)
|
if(f == 0)
|
return argc;
|
return argc;
|
else if(f == '%')
|
else if(f == '%')
|
{
|
{
|
width = 0;
|
width = 0;
|
fill = ' ';
|
fill = ' ';
|
f = *format++;
|
f = *format++;
|
while('0' <= f && f <= '9')
|
while('0' <= f && f <= '9')
|
{
|
{
|
width = width * 10 + f - '0';
|
width = width * 10 + f - '0';
|
f = *format++;
|
f = *format++;
|
}
|
}
|
if(f == '.')
|
if(f == '.')
|
{
|
{
|
fill = '0';
|
fill = '0';
|
f = *format++;
|
f = *format++;
|
}
|
}
|
if(f == 0)
|
if(f == 0)
|
return argc;
|
return argc;
|
|
|
if(f == 'd')
|
if(f == 'd')
|
{
|
{
|
memset(s, fill, width);
|
memset(s, fill, width);
|
itoa(argv[argc++], text, 10);
|
itoa(argv[argc++], text, 10);
|
length = (int)strlen(text);
|
length = (int)strlen(text);
|
if(width < length)
|
if(width < length)
|
width = length;
|
width = length;
|
strcpy(s + width - length, text);
|
strcpy(s + width - length, text);
|
}
|
}
|
else if(f == 'x' || f == 'f')
|
else if(f == 'x' || f == 'f')
|
{
|
{
|
memset(s, '0', width);
|
memset(s, '0', width);
|
itoa(argv[argc++], text, 16);
|
itoa(argv[argc++], text, 16);
|
length = (int)strlen(text);
|
length = (int)strlen(text);
|
if(width < length)
|
if(width < length)
|
width = length;
|
width = length;
|
strcpy(s + width - length, text);
|
strcpy(s + width - length, text);
|
}
|
}
|
else if(f == 'c')
|
else if(f == 'c')
|
{
|
{
|
*s++ = (char)argv[argc++];
|
*s++ = (char)argv[argc++];
|
*s = 0;
|
*s = 0;
|
}
|
}
|
else if(f == 's')
|
else if(f == 's')
|
{
|
{
|
length = strlen((char*)argv[argc]);
|
length = strlen((char*)argv[argc]);
|
if(width > length)
|
if(width > length)
|
{
|
{
|
memset(s, ' ', width - length);
|
memset(s, ' ', width - length);
|
s += width - length;
|
s += width - length;
|
}
|
}
|
strcpy(s, (char*)argv[argc++]);
|
strcpy(s, (char*)argv[argc++]);
|
}
|
}
|
s += strlen(s);
|
s += strlen(s);
|
}
|
}
|
else
|
else
|
{
|
{
|
if(f == '\n' && prev != '\r')
|
if(f == '\n' && prev != '\r')
|
*s++ = '\r';
|
*s++ = '\r';
|
*s++ = f;
|
*s++ = f;
|
}
|
}
|
*s = 0;
|
*s = 0;
|
}
|
}
|
}
|
}
|
|
|
|
|
int sscanf(const char *s, const char *format,
|
int sscanf(const char *s, const char *format,
|
int arg0, int arg1, int arg2, int arg3,
|
int arg0, int arg1, int arg2, int arg3,
|
int arg4, int arg5, int arg6, int arg7)
|
int arg4, int arg5, int arg6, int arg7)
|
{
|
{
|
int argv[8];
|
int argv[8];
|
int argc=0;
|
int argc=0;
|
char f, *ptr;
|
char f, *ptr;
|
|
|
argv[0] = arg0; argv[1] = arg1; argv[2] = arg2; argv[3] = arg3;
|
argv[0] = arg0; argv[1] = arg1; argv[2] = arg2; argv[3] = arg3;
|
argv[4] = arg4; argv[5] = arg5; argv[6] = arg6; argv[7] = arg7;
|
argv[4] = arg4; argv[5] = arg5; argv[6] = arg6; argv[7] = arg7;
|
|
|
for(;;)
|
for(;;)
|
{
|
{
|
if(*s == 0)
|
if(*s == 0)
|
return argc;
|
return argc;
|
f = *format++;
|
f = *format++;
|
if(f == 0)
|
if(f == 0)
|
return argc;
|
return argc;
|
else if(f == '%')
|
else if(f == '%')
|
{
|
{
|
while(isspace(*s))
|
while(isspace(*s))
|
++s;
|
++s;
|
f = *format++;
|
f = *format++;
|
if(f == 0)
|
if(f == 0)
|
return argc;
|
return argc;
|
if(f == 'd')
|
if(f == 'd')
|
*(int*)argv[argc++] = strtol(s, (char**)&s, 10);
|
*(int*)argv[argc++] = strtol(s, (char**)&s, 10);
|
else if(f == 'x')
|
else if(f == 'x')
|
*(int*)argv[argc++] = strtol(s, (char**)&s, 16);
|
*(int*)argv[argc++] = strtol(s, (char**)&s, 16);
|
else if(f == 'c')
|
else if(f == 'c')
|
*(char*)argv[argc++] = *s++;
|
*(char*)argv[argc++] = *s++;
|
else if(f == 's')
|
else if(f == 's')
|
{
|
{
|
ptr = (char*)argv[argc++];
|
ptr = (char*)argv[argc++];
|
while(!isspace(*s))
|
while(!isspace(*s))
|
*ptr++ = *s++;
|
*ptr++ = *s++;
|
*ptr = 0;
|
*ptr = 0;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
while(*s && *s != f)
|
while(*s && *s != f)
|
++s;
|
++s;
|
if(*s)
|
if(*s)
|
++s;
|
++s;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
#ifdef INCLUDE_DUMP
|
#ifdef INCLUDE_DUMP
|
/*********************** dump ***********************/
|
/*********************** dump ***********************/
|
void dump(const unsigned char *data, int length)
|
void dump(const unsigned char *data, int length)
|
{
|
{
|
int i, index=0, value;
|
int i, index=0, value;
|
char string[80];
|
char string[80];
|
memset(string, 0, sizeof(string));
|
memset(string, 0, sizeof(string));
|
for(i = 0; i < length; ++i)
|
for(i = 0; i < length; ++i)
|
{
|
{
|
if((i & 15) == 0)
|
if((i & 15) == 0)
|
{
|
{
|
if(strlen(string))
|
if(strlen(string))
|
printf("%s\n", string);
|
printf("%s\n", string);
|
printf("%4x ", i);
|
printf("%4x ", i);
|
memset(string, 0, sizeof(string));
|
memset(string, 0, sizeof(string));
|
index = 0;
|
index = 0;
|
}
|
}
|
value = data[i];
|
value = data[i];
|
printf("%2x ", value);
|
printf("%2x ", value);
|
if(isprint(value))
|
if(isprint(value))
|
string[index] = (char)value;
|
string[index] = (char)value;
|
else
|
else
|
string[index] = '.';
|
string[index] = '.';
|
++index;
|
++index;
|
}
|
}
|
for(; index < 16; ++index)
|
for(; index < 16; ++index)
|
printf(" ");
|
printf(" ");
|
printf("%s\n", string);
|
printf("%s\n", string);
|
}
|
}
|
#endif //INCLUDE_DUMP
|
#endif //INCLUDE_DUMP
|
|
|
|
|
#ifdef INCLUDE_QSORT
|
#ifdef INCLUDE_QSORT
|
/*********************** qsort ***********************/
|
/*********************** qsort ***********************/
|
static void QsortSwap(char *base, long left, long right, long size)
|
static void QsortSwap(char *base, long left, long right, long size)
|
{
|
{
|
int temp, i;
|
int temp, i;
|
char *ptrLeft, *ptrRight;
|
char *ptrLeft, *ptrRight;
|
ptrLeft = base + left * size;
|
ptrLeft = base + left * size;
|
ptrRight = base + right * size;
|
ptrRight = base + right * size;
|
for(i = 0; i < size; ++i)
|
for(i = 0; i < size; ++i)
|
{
|
{
|
temp = ptrLeft[i];
|
temp = ptrLeft[i];
|
ptrLeft[i] = ptrRight[i];
|
ptrLeft[i] = ptrRight[i];
|
ptrRight[i] = (char)temp;
|
ptrRight[i] = (char)temp;
|
}
|
}
|
}
|
}
|
|
|
|
|
//Modified from K&R
|
//Modified from K&R
|
static void qsort2(void *base, long left, long right, long size,
|
static void qsort2(void *base, long left, long right, long size,
|
int (*cmp)(const void *,const void *))
|
int (*cmp)(const void *,const void *))
|
{
|
{
|
int i, last;
|
int i, last;
|
char *base2=(char*)base, *pivot;
|
char *base2=(char*)base, *pivot;
|
if(left >= right)
|
if(left >= right)
|
return;
|
return;
|
QsortSwap(base2, left, (left + right)/2, size);
|
QsortSwap(base2, left, (left + right)/2, size);
|
last = left;
|
last = left;
|
pivot = &base2[left*size];
|
pivot = &base2[left*size];
|
for(i = left + 1; i <= right; ++i)
|
for(i = left + 1; i <= right; ++i)
|
{
|
{
|
if(cmp(&base2[i*size], pivot) < 0)
|
if(cmp(&base2[i*size], pivot) < 0)
|
QsortSwap(base2, ++last, i, size);
|
QsortSwap(base2, ++last, i, size);
|
}
|
}
|
QsortSwap(base2, left, last, size);
|
QsortSwap(base2, left, last, size);
|
qsort2(base, left, last-1, size, cmp);
|
qsort2(base, left, last-1, size, cmp);
|
qsort2(base, last+1, right, size, cmp);
|
qsort2(base, last+1, right, size, cmp);
|
}
|
}
|
|
|
|
|
void qsort(void *base,
|
void qsort(void *base,
|
long n,
|
long n,
|
long size,
|
long size,
|
int (*cmp)(const void *,const void *))
|
int (*cmp)(const void *,const void *))
|
{
|
{
|
qsort2(base, 0, n-1, size, cmp);
|
qsort2(base, 0, n-1, size, cmp);
|
}
|
}
|
|
|
|
|
void *bsearch(const void *key,
|
void *bsearch(const void *key,
|
const void *base,
|
const void *base,
|
long n,
|
long n,
|
long size,
|
long size,
|
int (*cmp)(const void *,const void *))
|
int (*cmp)(const void *,const void *))
|
{
|
{
|
long cond, low=0, high=n-1, mid;
|
long cond, low=0, high=n-1, mid;
|
char *base2=(char*)base;
|
char *base2=(char*)base;
|
while(low <= high)
|
while(low <= high)
|
{
|
{
|
mid = (low + high)/2;
|
mid = (low + high)/2;
|
cond = cmp(key, &base2[mid*size]);
|
cond = cmp(key, &base2[mid*size]);
|
if(cond < 0)
|
if(cond < 0)
|
high = mid - 1;
|
high = mid - 1;
|
else if(cond > 0)
|
else if(cond > 0)
|
low = mid + 1;
|
low = mid + 1;
|
else
|
else
|
return &base2[mid * size];
|
return &base2[mid * size];
|
}
|
}
|
return NULL;
|
return NULL;
|
}
|
}
|
#endif //INCLUDE_QSORT
|
#endif //INCLUDE_QSORT
|
|
|
|
|
#ifdef INCLUDE_TIMELIB
|
#ifdef INCLUDE_TIMELIB
|
/************************* time.h ***********************/
|
/************************* time.h ***********************/
|
#define SEC_PER_YEAR (365L*24*60*60)
|
#define SEC_PER_YEAR (365L*24*60*60)
|
#define SEC_PER_DAY (24L*60*60)
|
#define SEC_PER_DAY (24L*60*60)
|
//typedef unsigned long time_t; //start at 1/1/80
|
//typedef unsigned long time_t; //start at 1/1/80
|
//struct tm {
|
//struct tm {
|
// int tm_sec; //(0,59)
|
// int tm_sec; //(0,59)
|
// int tm_min; //(0,59)
|
// int tm_min; //(0,59)
|
// int tm_hour; //(0,23)
|
// int tm_hour; //(0,23)
|
// int tm_mday; //(1,31)
|
// int tm_mday; //(1,31)
|
// int tm_mon; //(0,11)
|
// int tm_mon; //(0,11)
|
// int tm_year; //(0,n) from 1900
|
// int tm_year; //(0,n) from 1900
|
// int tm_wday; //(0,6) calculated
|
// int tm_wday; //(0,6) calculated
|
// int tm_yday; //(0,365) calculated
|
// int tm_yday; //(0,365) calculated
|
// int tm_isdst; //hour adjusted for day light savings
|
// int tm_isdst; //hour adjusted for day light savings
|
//};
|
//};
|
static const unsigned short DaysUntilMonth[]=
|
static const unsigned short DaysUntilMonth[]=
|
{0,31,59,90,120,151,181,212,243,273,304,334,365};
|
{0,31,59,90,120,151,181,212,243,273,304,334,365};
|
static const unsigned short DaysInMonth[]=
|
static const unsigned short DaysInMonth[]=
|
{31,28,31,30,31,30,31,31,30,31,30,31};
|
{31,28,31,30,31,30,31,31,30,31,30,31};
|
static time_t DstTimeIn, DstTimeOut;
|
static time_t DstTimeIn, DstTimeOut;
|
|
|
|
|
/* Leap year if divisible by 4. Centenary years should only be
|
/* Leap year if divisible by 4. Centenary years should only be
|
leap-years if they were divisible by 400. */
|
leap-years if they were divisible by 400. */
|
static int IsLeapYear(int year)
|
static int IsLeapYear(int year)
|
{
|
{
|
return(((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0));
|
return(((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0));
|
}
|
}
|
|
|
time_t mktime(struct tm *tp)
|
time_t mktime(struct tm *tp)
|
{
|
{
|
time_t seconds;
|
time_t seconds;
|
unsigned long days, y, year;
|
unsigned long days, y, year;
|
|
|
days = tp->tm_mday - 1 + DaysUntilMonth[tp->tm_mon] +
|
days = tp->tm_mday - 1 + DaysUntilMonth[tp->tm_mon] +
|
365 * (tp->tm_year - 80);
|
365 * (tp->tm_year - 80);
|
seconds = (unsigned long)tp->tm_sec + 60L * (tp->tm_min +
|
seconds = (unsigned long)tp->tm_sec + 60L * (tp->tm_min +
|
60L * (tp->tm_hour + 24L * days));
|
60L * (tp->tm_hour + 24L * days));
|
if(tp->tm_isdst)
|
if(tp->tm_isdst)
|
seconds -= 60 * 60;
|
seconds -= 60 * 60;
|
year = 1900 + tp->tm_year - (tp->tm_mon < 2);
|
year = 1900 + tp->tm_year - (tp->tm_mon < 2);
|
for(y = 1980; y <= year; y += 4)
|
for(y = 1980; y <= year; y += 4)
|
{
|
{
|
if(y % 100 != 0 || y % 400 == 0)
|
if(y % 100 != 0 || y % 400 == 0)
|
seconds += SEC_PER_DAY;
|
seconds += SEC_PER_DAY;
|
}
|
}
|
return seconds;
|
return seconds;
|
}
|
}
|
|
|
|
|
void gmtime_r(const time_t *tp, struct tm *out)
|
void gmtime_r(const time_t *tp, struct tm *out)
|
{
|
{
|
time_t seconds, delta, secondsIn=*tp;
|
time_t seconds, delta, secondsIn=*tp;
|
int isLeapYear;
|
int isLeapYear;
|
unsigned long year, month;
|
unsigned long year, month;
|
|
|
out->tm_isdst = 0;
|
out->tm_isdst = 0;
|
if(DstTimeIn <= secondsIn && secondsIn < DstTimeOut)
|
if(DstTimeIn <= secondsIn && secondsIn < DstTimeOut)
|
{
|
{
|
secondsIn += 60 * 60;
|
secondsIn += 60 * 60;
|
out->tm_isdst = 1;
|
out->tm_isdst = 1;
|
}
|
}
|
seconds = secondsIn;
|
seconds = secondsIn;
|
for(year = 0; ; ++year)
|
for(year = 0; ; ++year)
|
{
|
{
|
delta = SEC_PER_YEAR + IsLeapYear(1980 + year) * SEC_PER_DAY;
|
delta = SEC_PER_YEAR + IsLeapYear(1980 + year) * SEC_PER_DAY;
|
if(seconds >= delta)
|
if(seconds >= delta)
|
seconds -= delta;
|
seconds -= delta;
|
else
|
else
|
break;
|
break;
|
}
|
}
|
out->tm_year = year + 80;
|
out->tm_year = year + 80;
|
out->tm_yday = seconds / SEC_PER_DAY;
|
out->tm_yday = seconds / SEC_PER_DAY;
|
isLeapYear = IsLeapYear(1980 + year);
|
isLeapYear = IsLeapYear(1980 + year);
|
for(month = 0; ; ++month)
|
for(month = 0; ; ++month)
|
{
|
{
|
delta = SEC_PER_DAY * (DaysInMonth[month] + (isLeapYear && (month == 1)));
|
delta = SEC_PER_DAY * (DaysInMonth[month] + (isLeapYear && (month == 1)));
|
if(seconds >= delta)
|
if(seconds >= delta)
|
seconds -= delta;
|
seconds -= delta;
|
else
|
else
|
break;
|
break;
|
}
|
}
|
out->tm_mon = month;
|
out->tm_mon = month;
|
out->tm_mday = seconds / SEC_PER_DAY;
|
out->tm_mday = seconds / SEC_PER_DAY;
|
seconds -= out->tm_mday * SEC_PER_DAY;
|
seconds -= out->tm_mday * SEC_PER_DAY;
|
++out->tm_mday;
|
++out->tm_mday;
|
out->tm_hour = seconds / (60 * 60);
|
out->tm_hour = seconds / (60 * 60);
|
seconds -= out->tm_hour * (60 * 60);
|
seconds -= out->tm_hour * (60 * 60);
|
out->tm_min = seconds / 60;
|
out->tm_min = seconds / 60;
|
seconds -= out->tm_min * 60;
|
seconds -= out->tm_min * 60;
|
out->tm_sec = seconds;
|
out->tm_sec = seconds;
|
seconds = secondsIn % (SEC_PER_DAY * 7);
|
seconds = secondsIn % (SEC_PER_DAY * 7);
|
out->tm_wday = (seconds / SEC_PER_DAY + 2) % 7; /* 1/1/80 is a Tue */
|
out->tm_wday = (seconds / SEC_PER_DAY + 2) % 7; /* 1/1/80 is a Tue */
|
//printf("%4.d/%2.d/%2.d:%2.d:%2.d:%2.d\n",
|
//printf("%4.d/%2.d/%2.d:%2.d:%2.d:%2.d\n",
|
// out->tm_year+1900, out->tm_mon+1, out->tm_mday,
|
// out->tm_year+1900, out->tm_mon+1, out->tm_mday,
|
// out->tm_hour, out->tm_min, out->tm_sec);
|
// out->tm_hour, out->tm_min, out->tm_sec);
|
}
|
}
|
|
|
|
|
void gmtimeDst(time_t dstTimeIn, time_t dstTimeOut)
|
void gmtimeDst(time_t dstTimeIn, time_t dstTimeOut)
|
{
|
{
|
DstTimeIn = dstTimeIn;
|
DstTimeIn = dstTimeIn;
|
DstTimeOut = dstTimeOut;
|
DstTimeOut = dstTimeOut;
|
}
|
}
|
|
|
|
|
//DST from 2am on the second Sunday in March to 2am first Sunday in November
|
//DST from 2am on the second Sunday in March to 2am first Sunday in November
|
void gmtimeDstSet(time_t *tp, time_t *dstTimeIn, time_t *dstTimeOut)
|
void gmtimeDstSet(time_t *tp, time_t *dstTimeIn, time_t *dstTimeOut)
|
{
|
{
|
time_t seconds, timeIn, timeOut;
|
time_t seconds, timeIn, timeOut;
|
struct tm tmDate;
|
struct tm tmDate;
|
int year, days;
|
int year, days;
|
|
|
DstTimeIn = 0;
|
DstTimeIn = 0;
|
DstTimeOut = 0;
|
DstTimeOut = 0;
|
gmtime_r(tp, &tmDate);
|
gmtime_r(tp, &tmDate);
|
year = tmDate.tm_year;
|
year = tmDate.tm_year;
|
|
|
//March 1, year, 2AM -> second Sunday
|
//March 1, year, 2AM -> second Sunday
|
tmDate.tm_year = year;
|
tmDate.tm_year = year;
|
tmDate.tm_mon = 2;
|
tmDate.tm_mon = 2;
|
tmDate.tm_mday = 1;
|
tmDate.tm_mday = 1;
|
tmDate.tm_hour = 2;
|
tmDate.tm_hour = 2;
|
tmDate.tm_min = 0;
|
tmDate.tm_min = 0;
|
tmDate.tm_sec = 0;
|
tmDate.tm_sec = 0;
|
seconds = mktime(&tmDate);
|
seconds = mktime(&tmDate);
|
gmtime_r(&seconds, &tmDate);
|
gmtime_r(&seconds, &tmDate);
|
days = 7 - tmDate.tm_wday + 7;
|
days = 7 - tmDate.tm_wday + 7;
|
*dstTimeIn = timeIn = seconds + days * SEC_PER_DAY;
|
*dstTimeIn = timeIn = seconds + days * SEC_PER_DAY;
|
|
|
//November 1, year, 2AM -> first Sunday
|
//November 1, year, 2AM -> first Sunday
|
tmDate.tm_year = year;
|
tmDate.tm_year = year;
|
tmDate.tm_mon = 10;
|
tmDate.tm_mon = 10;
|
tmDate.tm_mday = 1;
|
tmDate.tm_mday = 1;
|
tmDate.tm_hour = 2;
|
tmDate.tm_hour = 2;
|
tmDate.tm_min = 0;
|
tmDate.tm_min = 0;
|
tmDate.tm_sec = 0;
|
tmDate.tm_sec = 0;
|
seconds = mktime(&tmDate);
|
seconds = mktime(&tmDate);
|
gmtime_r(&seconds, &tmDate);
|
gmtime_r(&seconds, &tmDate);
|
days = 7 - tmDate.tm_wday;
|
days = 7 - tmDate.tm_wday;
|
*dstTimeOut = timeOut = seconds + days * SEC_PER_DAY;
|
*dstTimeOut = timeOut = seconds + days * SEC_PER_DAY;
|
|
|
DstTimeIn = timeIn;
|
DstTimeIn = timeIn;
|
DstTimeOut = timeOut;
|
DstTimeOut = timeOut;
|
}
|
}
|
#endif //INCLUDE_TIMELIB
|
#endif //INCLUDE_TIMELIB
|
|
|
|
|
