376 lines
8.1 KiB
C++
376 lines
8.1 KiB
C++
|
|
/*******************************************************************************
|
|
|
|
Copyright (c) 1995-96 Microsoft Corporation
|
|
|
|
Abstract:
|
|
|
|
{Insert General Comment Here}
|
|
|
|
*******************************************************************************/
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <windows.h>
|
|
#include <malloc.h>
|
|
#include <tchar.h>
|
|
#include <ctype.h>
|
|
#include "crt.h"
|
|
//#pragma function( strcpy, strlen, strcat )
|
|
// *** Flag these as don't use ***//
|
|
int vsprintf( char *buffer, const char *format, va_list argptr )
|
|
{
|
|
#ifdef _DEBUG
|
|
OutputDebugString(_T("Don't use vsprintf(), use wsprintf if possible\n"));
|
|
#endif
|
|
return strlen(buffer);
|
|
}
|
|
|
|
// *** Memory functions *** //
|
|
extern "C" void * __cdecl malloc( size_t size )
|
|
{
|
|
return GlobalAlloc(GMEM_FIXED,size);
|
|
}
|
|
|
|
extern "C" void __cdecl free( void * p )
|
|
{
|
|
GlobalFree(GlobalHandle(p));
|
|
}
|
|
|
|
extern "C" void * __cdecl realloc( void * pv, size_t newsize )
|
|
{
|
|
return GlobalLock(GlobalReAlloc(GlobalHandle(pv),newsize, NULL));
|
|
}
|
|
|
|
void __cdecl operator delete( void * p )
|
|
{
|
|
if (p) free(p);
|
|
}
|
|
|
|
void * __cdecl operator new( unsigned int cb )
|
|
{
|
|
return malloc(cb);
|
|
}
|
|
|
|
// *** String functions *** //
|
|
|
|
extern "C" size_t _cdecl wcslen( const wchar_t *string )
|
|
{
|
|
const wchar_t *s1 = string;
|
|
while( *string )
|
|
{
|
|
string++;
|
|
}
|
|
return string - s1;
|
|
}
|
|
|
|
extern "C" wchar_t * _cdecl wcscpy( wchar_t *strDestination, const wchar_t *strSource )
|
|
{
|
|
wchar_t *pRet = strDestination;
|
|
while( *strDestination++ = *strSource++ )
|
|
;
|
|
return pRet;
|
|
}
|
|
|
|
extern "C" wchar_t * _cdecl wcsncpy( wchar_t *strDest, const wchar_t *strSource, size_t count )
|
|
{
|
|
if( count < 0 ) return NULL;
|
|
|
|
wchar_t *pRet = strDest;
|
|
DWORD i = wcslen(strSource);
|
|
if( i <= count )
|
|
{
|
|
while( *strDest++ = *strSource++ )
|
|
;
|
|
while( i++ < count )
|
|
*strDest++ = L'\0';
|
|
}
|
|
else
|
|
{
|
|
while( count-- )
|
|
*strDest++ = *strSource++;
|
|
}
|
|
return pRet;
|
|
}
|
|
|
|
extern "C" int __cdecl wcsncmp ( const wchar_t * first, const wchar_t * last, size_t count )
|
|
{
|
|
if (!count)
|
|
return(0);
|
|
|
|
while (--count && *first && *first == *last)
|
|
{
|
|
first++;
|
|
last++;
|
|
}
|
|
|
|
return((int)(*first - *last));
|
|
}
|
|
|
|
extern "C" int __cdecl wcscmp ( const wchar_t * first, const wchar_t * last )
|
|
{
|
|
while (*first && *first == *last)
|
|
{
|
|
first++;
|
|
last++;
|
|
}
|
|
|
|
return((int)(*first - *last));
|
|
}
|
|
|
|
extern "C" wchar_t * __cdecl wcsrchr ( const wchar_t * string, wchar_t ch )
|
|
{
|
|
const wchar_t * p = NULL;
|
|
while (TRUE)
|
|
{
|
|
if (*string == ch)
|
|
{
|
|
p = string;
|
|
}
|
|
if (*string == NULL)
|
|
{
|
|
return (wchar_t *)p;
|
|
}
|
|
string++;
|
|
}
|
|
}
|
|
|
|
extern "C" wchar_t * __cdecl wcschr ( const wchar_t * string, wchar_t ch )
|
|
{
|
|
while (*string && *string != (wchar_t)ch)
|
|
string++;
|
|
|
|
if (*string == (wchar_t)ch)
|
|
return((wchar_t *)string);
|
|
return(NULL);
|
|
}
|
|
|
|
|
|
extern "C" wchar_t * __cdecl wcsstr ( const wchar_t * wcs1, const wchar_t * wcs2 )
|
|
{
|
|
wchar_t *cp = (wchar_t *) wcs1;
|
|
wchar_t *s1, *s2;
|
|
|
|
while (*cp)
|
|
{
|
|
s1 = cp;
|
|
s2 = (wchar_t *) wcs2;
|
|
|
|
while ( *s1 && *s2 && !(*s1-*s2) )
|
|
s1++, s2++;
|
|
|
|
if (!*s2)
|
|
return(cp);
|
|
|
|
cp++;
|
|
}
|
|
|
|
return(NULL);
|
|
}
|
|
|
|
extern "C" wchar_t * __cdecl wcscat ( wchar_t * dst, const wchar_t * src )
|
|
{
|
|
wchar_t * cp = dst;
|
|
|
|
while( *cp )
|
|
cp++; /* find end of dst */
|
|
|
|
while( *cp++ = *src++ ) ; /* Copy src to end of dst */
|
|
|
|
return( dst ); /* return dst */
|
|
|
|
}
|
|
|
|
|
|
// miscellaneous
|
|
extern "C" int __cdecl _purecall()
|
|
{
|
|
DebugBreak();
|
|
return 0;
|
|
}
|
|
|
|
|
|
extern "C" char * __cdecl _ultoa ( unsigned long val, char *buf, int radix )
|
|
{
|
|
xtoa(val, buf, radix, 0);
|
|
return buf;
|
|
}
|
|
|
|
extern "C" wchar_t * __cdecl _ultow ( unsigned long val, wchar_t *buf, int radix )
|
|
{
|
|
char astring[40];
|
|
|
|
_ultoa (val, astring, radix);
|
|
MultiByteToWideChar (CP_ACP, MB_PRECOMPOSED, astring, -1, buf, 40);
|
|
return (buf);
|
|
}
|
|
|
|
extern "C" static void __cdecl xtoa ( unsigned long val, char *buf, unsigned radix, int is_neg )
|
|
{
|
|
char *p; /* pointer to traverse string */
|
|
char *firstdig; /* pointer to first digit */
|
|
char temp; /* temp char */
|
|
unsigned digval; /* value of digit */
|
|
|
|
p = buf;
|
|
|
|
if (is_neg) {
|
|
/* negative, so output '-' and negate */
|
|
*p++ = '-';
|
|
val = (unsigned long)(-(long)val);
|
|
}
|
|
|
|
firstdig = p; /* save pointer to first digit */
|
|
|
|
do {
|
|
digval = (unsigned) (val % radix);
|
|
val /= radix; /* get next digit */
|
|
|
|
/* convert to ascii and store */
|
|
if (digval > 9)
|
|
*p++ = (char) (digval - 10 + 'a'); /* a letter */
|
|
else
|
|
*p++ = (char) (digval + '0'); /* a digit */
|
|
} while (val > 0);
|
|
|
|
/* We now have the digit of the number in the buffer, but in reverse
|
|
order. Thus we reverse them now. */
|
|
|
|
*p-- = '\0'; /* terminate string; p points to last digit */
|
|
|
|
do {
|
|
temp = *p;
|
|
*p = *firstdig;
|
|
*firstdig = temp; /* swap *p and *firstdig */
|
|
--p;
|
|
++firstdig; /* advance to next two digits */
|
|
} while (firstdig < p); /* repeat until halfway */
|
|
}
|
|
|
|
|
|
extern "C" int __cdecl isspace(int c)
|
|
{
|
|
if( c == ' ' || (c >= 0x09 && c <= 0x0d) )
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
extern "C" int __cdecl isdigit(int c)
|
|
{
|
|
if( c >= '0' && c <= '9' ) return 1;
|
|
return 0;
|
|
}
|
|
|
|
extern "C" long __cdecl atol( const char *nptr )
|
|
{
|
|
int c; /* current char */
|
|
long total; /* current total */
|
|
int sign; /* if '-', then negative, otherwise positive */
|
|
|
|
/* skip whitespace */
|
|
while ( isspace((int)(unsigned char)*nptr) )
|
|
++nptr;
|
|
|
|
c = (int)(unsigned char)*nptr++;
|
|
sign = c; /* save sign indication */
|
|
if (c == '-' || c == '+')
|
|
c = (int)(unsigned char)*nptr++; /* skip sign */
|
|
|
|
total = 0;
|
|
|
|
while (isdigit(c)) {
|
|
total = 10 * total + (c - '0'); /* accumulate digit */
|
|
c = (int)(unsigned char)*nptr++; /* get next char */
|
|
}
|
|
|
|
if (sign == '-')
|
|
return -total;
|
|
else
|
|
return total; /* return result, negated if necessary */
|
|
}
|
|
|
|
|
|
extern "C" long __cdecl _wtol( const wchar_t *nptr )
|
|
{
|
|
char astring[20];
|
|
WideCharToMultiByte (CP_ACP, 0, nptr, -1, astring, 20, NULL, NULL);
|
|
return (atol(astring));
|
|
}
|
|
|
|
extern "C" int __cdecl wprintf( const wchar_t *format, ... )
|
|
{
|
|
return 0; // no characters printed
|
|
}
|
|
|
|
extern "C" void * __cdecl calloc( size_t num, size_t size )
|
|
{
|
|
long nBytes = num*size;
|
|
void *pRet = malloc( nBytes );
|
|
if( pRet )
|
|
{
|
|
ZeroMemory( pRet, nBytes );
|
|
}
|
|
return pRet;
|
|
}
|
|
|
|
extern "C" wchar_t * __cdecl _wcsdup( const wchar_t *strSource )
|
|
{
|
|
wchar_t *pRet = NULL;
|
|
|
|
if( strSource )
|
|
{
|
|
int nLen = wcslen( strSource );
|
|
pRet = (wchar_t*)malloc( (nLen+1) * sizeof(WCHAR) );
|
|
if( pRet )
|
|
{
|
|
wcscpy( pRet, strSource );
|
|
}
|
|
}
|
|
return pRet;
|
|
|
|
}
|
|
|
|
extern "C" char * __cdecl strncpy ( char * dest, const char * source, size_t count )
|
|
{
|
|
char *start = dest;
|
|
|
|
while (count && (*dest++ = *source++)) /* copy string */
|
|
count--;
|
|
|
|
if (count) /* pad out with zeroes */
|
|
while (--count)
|
|
*dest++ = '\0';
|
|
|
|
return(start);
|
|
}
|
|
|
|
|
|
extern "C" char * __cdecl strcpy(char * dst, const char * src)
|
|
{
|
|
char * cp = dst;
|
|
|
|
while( *cp++ = *src++ )
|
|
; /* Copy src over dst */
|
|
|
|
return( dst );
|
|
}
|
|
|
|
extern "C" char * __cdecl strcat ( char * dst, const char * src )
|
|
{
|
|
char * cp = dst;
|
|
|
|
while( *cp )
|
|
cp++; /* find end of dst */
|
|
|
|
while( *cp++ = *src++ ) ; /* Copy src to end of dst */
|
|
|
|
return( dst ); /* return dst */
|
|
}
|
|
|
|
extern "C" size_t __cdecl strlen ( const char * str )
|
|
{
|
|
const char *eos = str;
|
|
|
|
while( *eos++ ) ;
|
|
|
|
return( (int)(eos - str - 1) );
|
|
}
|