981 lines
22 KiB
C
981 lines
22 KiB
C
/*
|
|
* The C RunTime DLL
|
|
*
|
|
* Implements C run-time functionality as known from UNIX.
|
|
*
|
|
* Copyright 1996 Marcus Meissner
|
|
* Copyright 1996 Jukka Iivonen
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <time.h>
|
|
#include <ctype.h>
|
|
#include <math.h>
|
|
#include "win.h"
|
|
#include "windows.h"
|
|
#include "stddebug.h"
|
|
#include "debug.h"
|
|
#include "module.h"
|
|
#include "xmalloc.h"
|
|
#include "heap.h"
|
|
#include "crtdll.h"
|
|
#include "drive.h"
|
|
|
|
UINT32 CRTDLL_argc_dll; /* CRTDLL.23 */
|
|
LPSTR *CRTDLL_argv_dll; /* CRTDLL.24 */
|
|
LPSTR CRTDLL_acmdln_dll; /* CRTDLL.38 */
|
|
UINT32 CRTDLL_basemajor_dll; /* CRTDLL.42 */
|
|
UINT32 CRTDLL_baseminor_dll; /* CRTDLL.43 */
|
|
UINT32 CRTDLL_baseversion_dll; /* CRTDLL.44 */
|
|
LPSTR CRTDLL_environ_dll; /* CRTDLL.75 */
|
|
UINT32 CRTDLL_osmajor_dll; /* CRTDLL.241 */
|
|
UINT32 CRTDLL_osminor_dll; /* CRTDLL.242 */
|
|
UINT32 CRTDLL_osver_dll; /* CRTDLL.244 */
|
|
UINT32 CRTDLL_osversion_dll; /* CRTDLL.245 */
|
|
UINT32 CRTDLL_winmajor_dll; /* CRTDLL.329 */
|
|
UINT32 CRTDLL_winminor_dll; /* CRTDLL.330 */
|
|
UINT32 CRTDLL_winver_dll; /* CRTDLL.331 */
|
|
|
|
typedef VOID (*new_handler_type)(VOID);
|
|
|
|
static new_handler_type new_handler;
|
|
|
|
/*********************************************************************
|
|
* _GetMainArgs (CRTDLL.022)
|
|
*/
|
|
DWORD
|
|
CRTDLL__GetMainArgs(LPDWORD argc,LPSTR **argv,LPSTR *environ,DWORD flag)
|
|
{
|
|
char *cmdline;
|
|
char **xargv;
|
|
int xargc,i,afterlastspace;
|
|
DWORD version;
|
|
|
|
dprintf_crtdll(stderr,"__GetMainArgs(%p,%p,%p,%ld).\n",
|
|
argc,argv,environ,flag
|
|
);
|
|
CRTDLL_acmdln_dll = cmdline = xstrdup( GetCommandLine32A() );
|
|
|
|
version = GetVersion32();
|
|
CRTDLL_osver_dll = version >> 16;
|
|
CRTDLL_winminor_dll = version & 0xFF;
|
|
CRTDLL_winmajor_dll = (version>>8) & 0xFF;
|
|
CRTDLL_baseversion_dll = version >> 16;
|
|
CRTDLL_winver_dll = ((version >> 8) & 0xFF) + ((version & 0xFF) << 8);
|
|
CRTDLL_baseminor_dll = (version >> 16) & 0xFF;
|
|
CRTDLL_basemajor_dll = (version >> 24) & 0xFF;
|
|
CRTDLL_osversion_dll = version & 0xFFFF;
|
|
CRTDLL_osminor_dll = version & 0xFF;
|
|
CRTDLL_osmajor_dll = (version>>8) & 0xFF;
|
|
|
|
/* missing threading init */
|
|
|
|
i=0;xargv=NULL;xargc=0;afterlastspace=0;
|
|
while (cmdline[i]) {
|
|
if (cmdline[i]==' ') {
|
|
xargv=(char**)xrealloc(xargv,sizeof(char*)*(++xargc));
|
|
cmdline[i]='\0';
|
|
xargv[xargc-1] = xstrdup(cmdline+afterlastspace);
|
|
i++;
|
|
while (cmdline[i]==' ')
|
|
i++;
|
|
if (cmdline[i])
|
|
afterlastspace=i;
|
|
} else
|
|
i++;
|
|
}
|
|
xargv=(char**)xrealloc(xargv,sizeof(char*)*(++xargc));
|
|
cmdline[i]='\0';
|
|
xargv[xargc-1] = xstrdup(cmdline+afterlastspace);
|
|
CRTDLL_argc_dll = xargc;
|
|
*argc = xargc;
|
|
CRTDLL_argv_dll = xargv;
|
|
*argv = xargv;
|
|
|
|
/* FIXME ... use real environment */
|
|
*environ = xmalloc(sizeof(LPSTR));
|
|
CRTDLL_environ_dll = *environ;
|
|
(*environ)[0] = NULL;
|
|
return 0;
|
|
}
|
|
|
|
typedef void (*_INITTERMFUN)();
|
|
|
|
/*********************************************************************
|
|
* _initterm (CRTDLL.135)
|
|
*/
|
|
DWORD CRTDLL__initterm(_INITTERMFUN *start,_INITTERMFUN *end)
|
|
{
|
|
_INITTERMFUN *current;
|
|
|
|
dprintf_crtdll(stddeb,"_initterm(%p,%p)\n",start,end);
|
|
current=start;
|
|
while (current<end) {
|
|
if (*current) (*current)();
|
|
current++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* srand (CRTDLL.460)
|
|
*/
|
|
void CRTDLL_srand(DWORD seed)
|
|
{
|
|
/* FIXME: should of course be thread? process? local */
|
|
srand(seed);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* fprintf (CRTDLL.373)
|
|
*/
|
|
int CRTDLL_fprintf(DWORD *args)
|
|
{
|
|
/* FIXME: use args[0] */
|
|
return vfprintf(stderr,(LPSTR)(args[1]),args+2);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* printf (CRTDLL.440)
|
|
*/
|
|
int CRTDLL_printf(DWORD *args)
|
|
{
|
|
return vfprintf(stdout,(LPSTR)(args[0]),args+1);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* sprintf (CRTDLL.458)
|
|
*/
|
|
int CRTDLL_sprintf(DWORD *args)
|
|
{
|
|
return vsprintf((LPSTR)(args[0]),(LPSTR)(args[1]),args+2);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* time (CRTDLL.488)
|
|
*/
|
|
time_t CRTDLL_time(time_t *timeptr)
|
|
{
|
|
time_t curtime = time(NULL);
|
|
|
|
if (timeptr)
|
|
*timeptr = curtime;
|
|
return curtime;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _isatty (CRTDLL.137)
|
|
*/
|
|
BOOL32 CRTDLL__isatty(DWORD x)
|
|
{
|
|
dprintf_crtdll(stderr,"CRTDLL__isatty(%ld)\n",x);
|
|
return TRUE;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _write (CRTDLL.332)
|
|
*/
|
|
INT32 CRTDLL__write(DWORD x,LPVOID buf,DWORD len)
|
|
{
|
|
if (x<=2)
|
|
return write(x,buf,len);
|
|
/* hmm ... */
|
|
dprintf_crtdll(stderr,"CRTDLL__write(%ld,%p,%ld)\n",x,buf,len);
|
|
return len;
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* exit (CRTDLL.359)
|
|
*/
|
|
void CRTDLL_exit(DWORD ret)
|
|
{
|
|
dprintf_crtdll(stderr,"CRTDLL_exit(%ld)\n",ret);
|
|
ExitProcess(ret);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* fflush (CRTDLL.365)
|
|
*/
|
|
void CRTDLL_fflush(DWORD x)
|
|
{
|
|
dprintf_crtdll(stderr,"CRTDLL_fflush(%ld)\n",x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* gets (CRTDLL.391)
|
|
*/
|
|
LPSTR CRTDLL_gets(LPSTR buf)
|
|
{
|
|
/* BAD, for the whole WINE process blocks... just done this way to test
|
|
* windows95's ftp.exe.
|
|
*/
|
|
return gets(buf);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* abs (CRTDLL.339)
|
|
*/
|
|
INT32 CRTDLL_abs(INT32 x)
|
|
{
|
|
return abs(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* acos (CRTDLL.340)
|
|
*/
|
|
float CRTDLL_acos(float x)
|
|
{
|
|
return acos(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* asin (CRTDLL.342)
|
|
*/
|
|
float CRTDLL_asin(float x)
|
|
{
|
|
return asin(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* atan (CRTDLL.343)
|
|
*/
|
|
float CRTDLL_atan(float x)
|
|
{
|
|
return atan(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* atan2 (CRTDLL.344)
|
|
*/
|
|
float CRTDLL_atan2(float x, float y)
|
|
{
|
|
return atan2(x,y);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* atof (CRTDLL.346)
|
|
*/
|
|
float CRTDLL_atof(LPCSTR x)
|
|
{
|
|
return atof(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* atoi (CRTDLL.347)
|
|
*/
|
|
INT32 CRTDLL_atoi(LPCSTR x)
|
|
{
|
|
return atoi(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* atol (CRTDLL.348)
|
|
*/
|
|
LONG CRTDLL_atol(LPCSTR x)
|
|
{
|
|
return atol(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* cos (CRTDLL.354)
|
|
*/
|
|
float CRTDLL_cos(float x)
|
|
{
|
|
return cos(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* cosh (CRTDLL.355)
|
|
*/
|
|
float CRTDLL_cosh(float x)
|
|
{
|
|
return cosh(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* exp (CRTDLL.360)
|
|
*/
|
|
float CRTDLL_exp(float x)
|
|
{
|
|
return exp(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* fabs (CRTDLL.361)
|
|
*/
|
|
float CRTDLL_fabs(float x)
|
|
{
|
|
return fabs(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* isalnum (CRTDLL.394)
|
|
*/
|
|
CHAR CRTDLL_isalnum(CHAR x)
|
|
{
|
|
return isalnum(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* isalpha (CRTDLL.395)
|
|
*/
|
|
CHAR CRTDLL_isalpha(CHAR x)
|
|
{
|
|
return isalpha(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* iscntrl (CRTDLL.396)
|
|
*/
|
|
CHAR CRTDLL_iscntrl(CHAR x)
|
|
{
|
|
return iscntrl(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* isdigit (CRTDLL.397)
|
|
*/
|
|
CHAR CRTDLL_isdigit(CHAR x)
|
|
{
|
|
return isdigit(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* isgraph (CRTDLL.398)
|
|
*/
|
|
CHAR CRTDLL_isgraph(CHAR x)
|
|
{
|
|
return isgraph(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* islower (CRTDLL.400)
|
|
*/
|
|
CHAR CRTDLL_islower(CHAR x)
|
|
{
|
|
return islower(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* isprint (CRTDLL.401)
|
|
*/
|
|
CHAR CRTDLL_isprint(CHAR x)
|
|
{
|
|
return isprint(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* ispunct (CRTDLL.402)
|
|
*/
|
|
CHAR CRTDLL_ispunct(CHAR x)
|
|
{
|
|
return ispunct(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* isspace (CRTDLL.403)
|
|
*/
|
|
CHAR CRTDLL_isspace(CHAR x)
|
|
{
|
|
return isspace(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* isupper (CRTDLL.404)
|
|
*/
|
|
CHAR CRTDLL_isupper(CHAR x)
|
|
{
|
|
return isupper(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* isxdigit (CRTDLL.418)
|
|
*/
|
|
CHAR CRTDLL_isxdigit(CHAR x)
|
|
{
|
|
return isxdigit(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* labs (CRTDLL.419)
|
|
*/
|
|
LONG CRTDLL_labs(LONG x)
|
|
{
|
|
return labs(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* log (CRTDLL.424)
|
|
*/
|
|
float CRTDLL_log(float x)
|
|
{
|
|
return log(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* log10 (CRTDLL.425)
|
|
*/
|
|
float CRTDLL_log10(float x)
|
|
{
|
|
return log10(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* pow (CRTDLL.439)
|
|
*/
|
|
float CRTDLL_pow(float x, float y)
|
|
{
|
|
return pow(x,y);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* rand (CRTDLL.446)
|
|
*/
|
|
INT32 CRTDLL_rand()
|
|
{
|
|
return rand();
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* sin (CRTDLL.456)
|
|
*/
|
|
float CRTDLL_sin(float x)
|
|
{
|
|
return sin(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* sinh (CRTDLL.457)
|
|
*/
|
|
float CRTDLL_sinh(float x)
|
|
{
|
|
return sinh(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* sqrt (CRTDLL.459)
|
|
*/
|
|
float CRTDLL_sqrt(float x)
|
|
{
|
|
return sqrt(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* tan (CRTDLL.486)
|
|
*/
|
|
float CRTDLL_tan(float x)
|
|
{
|
|
return tan(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* tanh (CRTDLL.487)
|
|
*/
|
|
float CRTDLL_tanh(float x)
|
|
{
|
|
return tanh(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* tolower (CRTDLL.491)
|
|
*/
|
|
CHAR CRTDLL_tolower(CHAR x)
|
|
{
|
|
return tolower(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* toupper (CRTDLL.492)
|
|
*/
|
|
CHAR CRTDLL_toupper(CHAR x)
|
|
{
|
|
return toupper(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* putchar (CRTDLL.442)
|
|
*/
|
|
void CRTDLL_putchar(INT32 x)
|
|
{
|
|
putchar(x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbsicmp (CRTDLL.204)
|
|
*/
|
|
int CRTDLL__mbsicmp(unsigned char *x,unsigned char *y)
|
|
{
|
|
do {
|
|
if (!*x)
|
|
return !!*y;
|
|
if (!*y)
|
|
return !!*x;
|
|
/* FIXME: MBCS handling... */
|
|
if (*x!=*y)
|
|
return 1;
|
|
x++;
|
|
y++;
|
|
} while (1);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbsinc (CRTDLL.205)
|
|
*/
|
|
unsigned char* CRTDLL__mbsinc(unsigned char *x)
|
|
{
|
|
/* FIXME: mbcs */
|
|
return x++;
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* vsprintf (CRTDLL.500)
|
|
*/
|
|
int CRTDLL_vsprintf(DWORD *args)
|
|
{
|
|
return vsprintf((char *)args[0],(char *)args[1],args+2);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* vsprintf (CRTDLL.500) (NTDLL.913)
|
|
*/
|
|
int CRTDLL_sscanf(DWORD *args)
|
|
{
|
|
return vsscanf((char *)args[0],(char *)args[1],args+2);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbscpy (CRTDLL.200)
|
|
*/
|
|
unsigned char* CRTDLL__mbscpy(unsigned char *x,unsigned char *y)
|
|
{
|
|
return strcpy(x,y);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbscat (CRTDLL.197)
|
|
*/
|
|
unsigned char* CRTDLL__mbscat(unsigned char *x,unsigned char *y)
|
|
{
|
|
return strcat(x,y);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _strupr (CRTDLL.300)
|
|
*/
|
|
LPSTR CRTDLL__strupr(LPSTR x)
|
|
{
|
|
LPSTR y=x;
|
|
|
|
while (*y) {
|
|
*y=toupper(*y);
|
|
y++;
|
|
}
|
|
return x;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _wcsupr (CRTDLL.328)
|
|
*/
|
|
LPWSTR CRTDLL__wcsupr(LPWSTR x)
|
|
{
|
|
LPWSTR y=x;
|
|
|
|
while (*y) {
|
|
*y=toupper(*y);
|
|
y++;
|
|
}
|
|
return x;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _wcslwr (CRTDLL.323)
|
|
*/
|
|
LPWSTR CRTDLL__wcslwr(LPWSTR x)
|
|
{
|
|
LPWSTR y=x;
|
|
|
|
while (*y) {
|
|
*y=tolower(*y);
|
|
y++;
|
|
}
|
|
return x;
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* malloc (CRTDLL.427)
|
|
*/
|
|
VOID* CRTDLL_malloc(DWORD size)
|
|
{
|
|
return HeapAlloc(GetProcessHeap(),0,size);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* new (CRTDLL.001)
|
|
*/
|
|
VOID* CRTDLL_new(DWORD size)
|
|
{
|
|
VOID* result;
|
|
if(!(result = HeapAlloc(GetProcessHeap(),0,size)) && new_handler)
|
|
(*new_handler)();
|
|
return result;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* set_new_handler(CRTDLL.003)
|
|
*/
|
|
new_handler_type CRTDLL_set_new_handler(new_handler_type func)
|
|
{
|
|
new_handler_type old_handler = new_handler;
|
|
new_handler = func;
|
|
return old_handler;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* calloc (CRTDLL.350)
|
|
*/
|
|
VOID* CRTDLL_calloc(DWORD size, DWORD count)
|
|
{
|
|
return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size * count );
|
|
}
|
|
|
|
/*********************************************************************
|
|
* realloc (CRTDLL.447)
|
|
*/
|
|
VOID* CRTDLL_realloc( VOID *ptr, DWORD size )
|
|
{
|
|
return HeapReAlloc( GetProcessHeap(), 0, ptr, size );
|
|
}
|
|
|
|
/*********************************************************************
|
|
* free (CRTDLL.427)
|
|
*/
|
|
VOID CRTDLL_free(LPVOID ptr)
|
|
{
|
|
HeapFree(GetProcessHeap(),0,ptr);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* delete (CRTDLL.002)
|
|
*/
|
|
VOID CRTDLL_delete(VOID* ptr)
|
|
{
|
|
HeapFree(GetProcessHeap(),0,ptr);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _strdup (CRTDLL.285)
|
|
*/
|
|
LPSTR CRTDLL__strdup(LPSTR ptr)
|
|
{
|
|
return HEAP_strdupA(GetProcessHeap(),0,ptr);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* fclose (CRTDLL.362)
|
|
*/
|
|
DWORD CRTDLL_fclose(LPVOID x)
|
|
{
|
|
dprintf_crtdll(stdnimp,"fclose(%p)\n",x);
|
|
return 0;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* setlocale (CRTDLL.453)
|
|
*/
|
|
LPSTR CRTDLL_setlocale(INT32 category,LPCSTR locale)
|
|
{
|
|
LPSTR categorystr;
|
|
|
|
switch (category) {
|
|
case CRTDLL_LC_ALL: categorystr="LC_ALL";break;
|
|
case CRTDLL_LC_COLLATE: categorystr="LC_COLLATE";break;
|
|
case CRTDLL_LC_CTYPE: categorystr="LC_CTYPE";break;
|
|
case CRTDLL_LC_MONETARY: categorystr="LC_MONETARY";break;
|
|
case CRTDLL_LC_NUMERIC: categorystr="LC_NUMERIC";break;
|
|
case CRTDLL_LC_TIME: categorystr="LC_TIME";break;
|
|
default: categorystr = "UNKNOWN?";break;
|
|
}
|
|
fprintf(stderr,"CRTDLL.setlocale(%s,%s),stub!\n",categorystr,locale);
|
|
return "C";
|
|
}
|
|
|
|
/*********************************************************************
|
|
* wcsspn (CRTDLL.516)
|
|
*/
|
|
INT32 CRTDLL_wcsspn(LPWSTR str,LPWSTR accept)
|
|
{
|
|
LPWSTR s,t;
|
|
|
|
s=str;
|
|
do {
|
|
t=accept;
|
|
while (*t) { if (*t==*s) break;t++;}
|
|
if (!*t) break;
|
|
s++;
|
|
} while (*s);
|
|
return s-str; /* nr of wchars */
|
|
}
|
|
|
|
/*********************************************************************
|
|
* wcscspn (CRTDLL.508)
|
|
*/
|
|
INT32 CRTDLL_wcscspn(LPWSTR str,LPWSTR reject)
|
|
{
|
|
LPWSTR s,t;
|
|
|
|
s=str;
|
|
do {
|
|
t=reject;
|
|
while (*t) { if (*t==*s) break;t++;}
|
|
if (*t) break;
|
|
s++;
|
|
} while (*s);
|
|
return s-str; /* nr of wchars */
|
|
}
|
|
|
|
/*********************************************************************
|
|
* wcschr (CRTDLL.504)
|
|
*/
|
|
LPWSTR CRTDLL_wcschr(LPWSTR str,WCHAR xchar)
|
|
{
|
|
LPWSTR s;
|
|
|
|
s=str;
|
|
do {
|
|
if (*s==xchar)
|
|
return s;
|
|
} while (*s++);
|
|
return NULL;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* towupper (CRTDLL.494)
|
|
*/
|
|
WCHAR CRTDLL_towupper(WCHAR x)
|
|
{
|
|
return (WCHAR)toupper((CHAR)x);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* swprintf (CRTDLL.483)
|
|
*/
|
|
DWORD CRTDLL_swprintf(DWORD *args)
|
|
{
|
|
return WIN32_wsprintf32W(args);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _wcsicoll (CRTDLL.322)
|
|
*/
|
|
DWORD CRTDLL__wcsicoll(LPWSTR a1,LPWSTR a2)
|
|
{
|
|
/* FIXME: handle collates */
|
|
return lstrcmpi32W(a1,a2);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* wcscoll (CRTDLL.506)
|
|
*/
|
|
DWORD CRTDLL_wcscoll(LPWSTR a1,LPWSTR a2)
|
|
{
|
|
/* FIXME: handle collates */
|
|
return lstrcmp32W(a1,a2);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _wcsrev (CRTDLL.326)
|
|
*/
|
|
VOID CRTDLL__wcsrev(LPWSTR s) {
|
|
LPWSTR e;
|
|
|
|
e=s;
|
|
while (*e)
|
|
e++;
|
|
while (s<e) {
|
|
WCHAR a;
|
|
|
|
a=*s;*s=*e;*e=a;
|
|
s++;e--;
|
|
}
|
|
}
|
|
|
|
/*********************************************************************
|
|
* wcsstr (CRTDLL.517)
|
|
*/
|
|
LPWSTR CRTDLL_wcsstr(LPWSTR s,LPWSTR b)
|
|
{
|
|
LPWSTR x,y,c;
|
|
|
|
x=s;
|
|
while (*x) {
|
|
if (*x==*b) {
|
|
y=x;c=b;
|
|
while (*y && *c && *y==*c) { c++;y++; }
|
|
if (!*c)
|
|
return x;
|
|
}
|
|
x++;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* wcsrchr (CRTDLL.515)
|
|
*/
|
|
LPWSTR CRTDLL_wcsrchr(LPWSTR str,WCHAR xchar)
|
|
{
|
|
LPWSTR s;
|
|
|
|
s=str+lstrlen32W(str);
|
|
do {
|
|
if (*s==xchar)
|
|
return s;
|
|
s--;
|
|
} while (s>=str);
|
|
return NULL;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _setmode (CRTDLL.265)
|
|
* FIXME: dunno what this is.
|
|
*/
|
|
DWORD
|
|
CRTDLL__setmode(LPVOID x,INT32 y) {
|
|
/* FIXME */
|
|
fprintf(stdnimp,"CRTDLL._setmode(%p,%d), STUB.\n",x,y);
|
|
return 0;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* atexit (CRTDLL.345)
|
|
*/
|
|
INT32
|
|
CRTDLL_atexit(LPVOID x) {
|
|
/* FIXME */
|
|
fprintf(stdnimp,"CRTDLL.atexit(%p), STUB.\n",x);
|
|
return 0; /* successful */
|
|
}
|
|
|
|
/*********************************************************************
|
|
* mbtowc (CRTDLL.430)
|
|
* FIXME: check multibyte support
|
|
*/
|
|
WCHAR
|
|
CRTDLL_mbtowc(CHAR a) {
|
|
return a;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _isctype (CRTDLL.138)
|
|
*/
|
|
BOOL32
|
|
CRTDLL__isctype(CHAR x,CHAR type) {
|
|
if ((type & CRTDLL_SPACE) && isspace(x))
|
|
return TRUE;
|
|
if ((type & CRTDLL_PUNCT) && ispunct(x))
|
|
return TRUE;
|
|
if ((type & CRTDLL_LOWER) && islower(x))
|
|
return TRUE;
|
|
if ((type & CRTDLL_UPPER) && isupper(x))
|
|
return TRUE;
|
|
if ((type & CRTDLL_ALPHA) && isalpha(x))
|
|
return TRUE;
|
|
if ((type & CRTDLL_DIGIT) && isdigit(x))
|
|
return TRUE;
|
|
if ((type & CRTDLL_CONTROL) && iscntrl(x))
|
|
return TRUE;
|
|
/* check CRTDLL_LEADBYTE */
|
|
return FALSE;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _chdrive (CRTDLL.52)
|
|
*/
|
|
BOOL32
|
|
CRTDLL__chdrive(INT32 newdrive) {
|
|
/* FIXME: generates errnos */
|
|
return DRIVE_SetCurrentDrive(newdrive);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _chdir (CRTDLL.51)
|
|
*/
|
|
INT32
|
|
CRTDLL__chdir(LPCSTR newdir) {
|
|
if (!SetCurrentDirectory32A(newdir))
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _mkdir (CRTDLL.234)
|
|
*/
|
|
INT32
|
|
CRTDLL__mkdir(LPCSTR newdir) {
|
|
if (!CreateDirectory32A(newdir,NULL))
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _errno (CRTDLL.52)
|
|
* Yes, this is a function.
|
|
*/
|
|
LPINT32
|
|
CRTDLL__errno() {
|
|
static int crtdllerrno;
|
|
extern int LastErrorToErrno(DWORD);
|
|
|
|
/* FIXME: we should set the error at the failing function call time */
|
|
crtdllerrno = LastErrorToErrno(GetLastError());
|
|
return &crtdllerrno;
|
|
}
|