#include <ndis.h>
//#include <ansihelp.h>
#define _XA 0x200
#define _XS 0x100
#define _BB 0x80
#define _CN 0x40
#define _DI 0x20
#define _LO 0x10
#define _PU 0x08
#define _SP 0x04
#define _UP 0x02
#define _XD 0x01
#define XDI (_DI | _XD)
#define XLO (_LO | _XD)
#define XUP (_UP | _XD)
static const SHORT CTypeTable[257] = {
0,
_BB, _BB, _BB, _BB, _BB, _BB, _BB, _BB,
_BB, _CN, _CN, _CN, _CN, _CN, _BB, _BB,
_BB, _BB, _BB, _BB, _BB, _BB, _BB, _BB,
_BB, _BB, _BB, _BB, _BB, _BB, _BB, _BB,
_SP, _PU, _PU, _PU, _PU, _PU, _PU, _PU,
_PU, _PU, _PU, _PU, _PU, _PU, _PU, _PU,
XDI, XDI, XDI, XDI, XDI, XDI, XDI, XDI,
XDI, XDI, _PU, _PU, _PU, _PU, _PU, _PU,
_PU, XUP, XUP, XUP, XUP, XUP, XUP, _PU,
_UP, _UP, _UP, _UP, _UP, _UP, _UP, _UP,
_UP, _UP, _UP, _UP, _UP, _UP, _UP, _UP,
_UP, _UP, _UP, _PU, _PU, _PU, _PU, _PU,
_PU, XLO, XLO, XLO, XLO, XLO, XLO, _LO,
_LO, _LO, _LO, _LO, _LO, _LO, _LO, _LO,
_LO, _LO, _LO, _LO, _LO, _LO, _LO, _LO,
_LO, _LO, _LO, _PU, _PU, _PU, _PU, _BB, };
const SHORT *_Ctype = &CTypeTable[1];
#define BASE_MAX 36
static const CHAR digits[] = {"0123456789abcdefghijklmnopqrstuvwxyz"};
static const CHAR ndigs[BASE_MAX+1] = {
0, 0, 33, 21, 17, 14, 13, 12, 11, 11,
10, 10, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8,
8, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7 };
ULONG __Stoul (const CHAR *s, CHAR **endptr, INT base);
/******************************************************************************
@doc INTERNAL
@internal ULONG | __strlen | string length
@parm PUCHAR | str | the string.
@rdesc ULONG | the length of the string.
******************************************************************************/
ULONG
__strlen(PUCHAR str)
{
ULONG len = 0;
if (str == NULL) {
return(0);
}
while (str[len] != '\0') {
len++;
}
return(len);
} // end of __strlen
/******************************************************************************
@doc INTERNAL
@internal LONG | __strcmp | compare strings
@parm PUCHAR | str1 | one string.
@parm PUCHAR | str2 | another string.
@rdesc ULONG | the comparison result.
******************************************************************************/
LONG
__strcmp(PUCHAR str1, PUCHAR str2)
{
ULONG len = 0;
if (str1 == str2) {
return(0);
}
if ((str1 == NULL) || (str2 == NULL)) {
return(-1);
}
while ((str1[len] == str2[len]) && (str1[len] != '\0') &&
(str2[len] != '\0')) {
len++;
}
if (str1[len] == str2[len]) {
return(0);
} else if (str1[len] < str2[len]) {
return(-1);
} else {
return(1);
}
} // end of __strcmp
/******************************************************************************
@doc INTERNAL
@internal LONG | __strncmp | compare strings
@parm PUCHAR | str1 | one string.
@parm PUCHAR | str2 | another string.
@parm ULONG | count | maximum characters to compare
@rdesc ULONG | the comparison result.
******************************************************************************/
LONG
__strncmp(PUCHAR str1, PUCHAR str2, ULONG count)
{
ULONG len = 0;
if (str1 == str2) {
return(0);
}
if ((str1 == NULL) || (str2 == NULL)) {
return(-1);
}
while (count-- && (str1[len] == str2[len]) && (str1[len] != '\0') &&
(str2[len] != '\0')) {
len++;
}
if (count == 0) {
len--;
}
if (str1[len] == str2[len]) {
return(0);
} else if (str1[len] < str2[len]) {
return(-1);
} else {
return(1);
}
} // end of __strncmp
/******************************************************************************
@doc INTERNAL
@internal LONG | __strnicmp | compare strings (case insensitive)
@parm PUCHAR | str1 | one string.
@parm PUCHAR | str2 | another string.
@parm ULONG | count | maximum characters to compare
@rdesc ULONG | the comparison result.
******************************************************************************/
LONG
__strnicmp(PUCHAR str1, PUCHAR str2, ULONG count)
{
ULONG len = 0;
if (str1 == str2) {
return(0);
}
if ((str1 == NULL) || (str2 == NULL)) {
return(-1);
}
while (count-- && (str1[len] == str2[len]) && (str1[len] != '\0') &&
(str2[len] != '\0')) {
len++;
}
if (count == 0) {
len--;
}
if (str1[len] == str2[len]) {
return(0);
} else if (str1[len] < str2[len]) {
return(-1);
} else {
return(1);
}
} // end of __strnicmp
/******************************************************************************
@doc INTERNAL
@internal PUCHAR | __strncpy | copy strings
@parm PUCHAR | str1 | one string.
@parm PUCHAR | str2 | another string.
@parm ULONG | count | maximum characters to copy
@rdesc ULONG |
******************************************************************************/
PUCHAR
__strncpy(PUCHAR str1, PUCHAR str2, ULONG count)
{
PUCHAR tmp = str1;
if (str1 && str2 && *str2 && count) {
while (count-- && (*str2 != '\0')) {
*str1++ = *str2++;
}
*str1 = '\0';
}
return (tmp);
} // end of __strncpy
/******************************************************************************
@doc INTERNAL
@internal PUCHAR | __strcpy | copy strings
@parm PUCHAR | str1 | one string.
@parm PUCHAR | str2 | another string.
@rdesc PUCHAR | the comparison result.
******************************************************************************/
PUCHAR
__strcpy(PUCHAR str1, PUCHAR str2)
{
PUCHAR tmp = str1;
if (str1 && str2 && *str2) {
while (*str2 != '\0') {
*str1++ = *str2++;
}
*str1 = *str2;
}
return (tmp);
} // end of __strcpy
/******************************************************************************
@doc INTERNAL
@internal PUCHAR | __strstr | search for substring with another string
@parm PUCHAR | str1 | source string.
@parm PUCHAR | str2 | substring string.
@rdesc PUCHAR |
******************************************************************************/
PUCHAR
__strstr(PUCHAR str1, PUCHAR str2)
{
return (NULL);
} // end of __strstr
/******************************************************************************
@doc INTERNAL
@internal PUCHAR | __memchr | search for char within buffer[0..count]
@parm PUCHAR | buffer | starting address.
@parm CHAR | chr | chr
@parm ULONG | count | count
@rdesc PUCHAR |
******************************************************************************/
PUCHAR
__memchr(PUCHAR buffer, CHAR chr, ULONG count)
{
ULONG len = 0;
if (buffer == NULL) {
return(NULL);
}
while ((len<count) && (buffer[len] != chr)) {
len++;
}
return ((len<count)?(buffer+len):NULL);
} // end of __memchr
/******************************************************************************
@doc INTERNAL
@internal PUCHAR | __strchr | search for char within a string
@parm PUCHAR | str1 | source string.
@parm CHAR | chr | chr
@rdesc PUCHAR |
******************************************************************************/
PUCHAR
__strchr(PUCHAR str1, CHAR chr)
{
ULONG len = 0;
if (str1 == NULL) {
return(NULL);
}
while ((str1[len] != '\0') && (str1[len] != chr)) {
len++;
}
return ((str1[len])?(str1+len):NULL);
} // end of __strchr
/******************************************************************************
@doc INTERNAL
@internal PUCHAR | __strrchr | reverse search for char within a string
@parm PUCHAR | str1 | source string.
@parm CHAR | chr | chr
@rdesc PUCHAR |
******************************************************************************/
PUCHAR
__strrchr(PUCHAR str1, CHAR chr)
{
ULONG len = 0;
return(NULL);
} // end of __strrchr
/******************************************************************************
@doc INTERNAL
@internal PUCHAR | __strlwr | convert a string to lowercase
@parm PUCHAR | str1 | source string.
@rdesc PUCHAR |
******************************************************************************/
PUCHAR
__strlwr(PUCHAR str1)
{
for( ; str1 != NULL, *str1 != '\0'; str1++ )
*str1 = tolower( *str1 );
return( str1 );
} // end of __strlwr
ULONG
__strtoul (const CHAR *s, INT base)
{
return(__Stoul (s, (CHAR **)NULL, base));
}
ULONG
__Stoul (const CHAR *s, CHAR **endptr, INT base)
{
const CHAR *sc, *sd;
const CHAR *s1, *s2;
CHAR sign;
LONG n;
ULONG x, y;
for (sc = s; isspace (*sc); ++sc);
sign = *sc == '-' || *sc == '+' ? *sc++ : '+';
if (base < 0 || base == 1 || BASE_MAX < base)
{
if (endptr)
*endptr = (CHAR *)s;
return( (ULONG)-1 );
}
else if (base)
{
if (base == 16 && *sc == '0' && (sc[1] == 'x' || sc[1] == 'X'))
sc += 2;
}
else if (*sc != '0')
base = 10;
else if (sc[1] == 'x' || sc[1] == 'X')
{
base = 16;
sc += 2;
}
else
base = 8;
for (s1 = sc; *sc == '0'; ++sc );
x = 0;
for (s2 = sc; (sd = memchr (digits, (INT)tolower(*sc), (UINT)base)) != NULL; ++sc)
{
y = x;
x = x * base + (sd - digits);
}
if (s1 == sc)
{
if (endptr)
*endptr = (CHAR *)s;
return( (ULONG)-1 );
}
n = sc - s2 - ndigs[base];
if (n < 0)
;
else if (0 < n || x < x - sc[-1] || (x - sc[-1]) / base != y)
{
// overflow
x = 0xFFFFFFFF;
}
if (sign == '-')
x = (ULONG)(0 - x);
if (endptr)
*endptr = (CHAR *)sc;
return(x);
}
INT
__isspace (INT c)
{
return(_Ctype[(INT)c] & (_CN | _SP | _XS));
}
PCHAR
__vsprintf()
{
return( NULL );
}
