misc/crtdll.c

   1 /*
   2  * The C RunTime DLL
   3  *
   4  * Implements C run-time functionality as known from UNIX.
   5  *
   6  * Copyright 1996 Marcus Meissner
   7  * Copyright 1996 Jukka Iivonen
   8  */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <stdarg.h>
  13 #include <string.h>
  14 #include <unistd.h>
  15 #include <time.h>
  16 #include <ctype.h>
  17 #include <math.h>
  18 #include "win.h"
  19 #include "windows.h"
  20 #include "stddebug.h"
  21 #include "debug.h"
  22 #include "module.h"
  23 #include "xmalloc.h"
  24 #include "heap.h"
  25 #include "crtdll.h"
  26 #include "drive.h"
  27
  28 UINT32 CRTDLL_argc_dll;         /* CRTDLL.23 */
  29 LPSTR *CRTDLL_argv_dll;         /* CRTDLL.24 */
  30 LPSTR  CRTDLL_acmdln_dll;       /* CRTDLL.38 */
  31 UINT32 CRTDLL_basemajor_dll;    /* CRTDLL.42 */
  32 UINT32 CRTDLL_baseminor_dll;    /* CRTDLL.43 */
  33 UINT32 CRTDLL_baseversion_dll;  /* CRTDLL.44 */
  34 LPSTR  CRTDLL_environ_dll;      /* CRTDLL.75 */
  35 UINT32 CRTDLL_osmajor_dll;      /* CRTDLL.241 */
  36 UINT32 CRTDLL_osminor_dll;      /* CRTDLL.242 */
  37 UINT32 CRTDLL_osver_dll;        /* CRTDLL.244 */
  38 UINT32 CRTDLL_osversion_dll;    /* CRTDLL.245 */
  39 UINT32 CRTDLL_winmajor_dll;     /* CRTDLL.329 */
  40 UINT32 CRTDLL_winminor_dll;     /* CRTDLL.330 */
  41 UINT32 CRTDLL_winver_dll;       /* CRTDLL.331 */
  42
  43 typedef VOID (*new_handler_type)(VOID);
  44
  45 static new_handler_type new_handler;
  46
  47 /*********************************************************************
  48  *                  _GetMainArgs  (CRTDLL.022)
  49  */
  50 DWORD
  51 CRTDLL__GetMainArgs(LPDWORD argc,LPSTR **argv,LPSTR *environ,DWORD flag)
  52 {
  53         char *cmdline;
  54         char  **xargv;
  55         int     xargc,i,afterlastspace;
  56         DWORD   version;
  57
  58         dprintf_crtdll(stderr,"__GetMainArgs(%p,%p,%p,%ld).\n",
  59                 argc,argv,environ,flag
  60         );
  61         CRTDLL_acmdln_dll = cmdline = xstrdup( GetCommandLine32A() );
  62
  63         version = GetVersion32();
  64         CRTDLL_osver_dll       = version >> 16;
  65         CRTDLL_winminor_dll    = version & 0xFF;
  66         CRTDLL_winmajor_dll    = (version>>8) & 0xFF;
  67         CRTDLL_baseversion_dll = version >> 16;
  68         CRTDLL_winver_dll      = ((version >> 8) & 0xFF) + ((version & 0xFF) << 8);
  69         CRTDLL_baseminor_dll   = (version >> 16) & 0xFF;
  70         CRTDLL_basemajor_dll   = (version >> 24) & 0xFF;
  71         CRTDLL_osversion_dll   = version & 0xFFFF;
  72         CRTDLL_osminor_dll     = version & 0xFF;
  73         CRTDLL_osmajor_dll     = (version>>8) & 0xFF;
  74
  75         /* missing threading init */
  76
  77         i=0;xargv=NULL;xargc=0;afterlastspace=0;
  78         while (cmdline[i]) {
  79                 if (cmdline[i]==' ') {
  80                         xargv=(char**)xrealloc(xargv,sizeof(char*)*(++xargc));
  81                         cmdline[i]='\0';
  82                         xargv[xargc-1] = xstrdup(cmdline+afterlastspace);
  83                         i++;
  84                         while (cmdline[i]==' ')
  85                                 i++;
  86                         if (cmdline[i])
  87                                 afterlastspace=i;
  88                 } else
  89                         i++;
  90         }
  91         xargv=(char**)xrealloc(xargv,sizeof(char*)*(++xargc));
  92         cmdline[i]='\0';
  93         xargv[xargc-1] = xstrdup(cmdline+afterlastspace);
  94         CRTDLL_argc_dll = xargc;
  95         *argc           = xargc;
  96         CRTDLL_argv_dll = xargv;
  97         *argv           = xargv;
  98
  99         /* FIXME ... use real environment */
 100         *environ        = xmalloc(sizeof(LPSTR));
 101         CRTDLL_environ_dll = *environ;
 102         (*environ)[0] = NULL;
 103         return 0;
 104 }
 105
 106 typedef void (*_INITTERMFUN)();
 107
 108 /*********************************************************************
 109  *                  _initterm     (CRTDLL.135)
 110  */
 111 DWORD CRTDLL__initterm(_INITTERMFUN *start,_INITTERMFUN *end)
 112 {
 113         _INITTERMFUN    *current;
 114
 115         dprintf_crtdll(stddeb,"_initterm(%p,%p)\n",start,end);
 116         current=start;
 117         while (current<end) {
 118                 if (*current) (*current)();
 119                 current++;
 120         }
 121         return 0;
 122 }
 123
 124 /*********************************************************************
 125  *                  srand         (CRTDLL.460)
 126  */
 127 void CRTDLL_srand(DWORD seed)
 128 {
 129         /* FIXME: should of course be thread? process? local */
 130         srand(seed);
 131 }
 132
 133 /*********************************************************************
 134  *                  fprintf       (CRTDLL.373)
 135  */
 136 int CRTDLL_fprintf(DWORD *args)
 137 {
 138         /* FIXME: use args[0] */
 139         /* CMF - This makes a BIG assumption about va_list */
 140         return vfprintf(stderr, (LPSTR) args[1], (va_list) &args[2]);
 141 }
 142
 143 /*********************************************************************
 144  *                  printf        (CRTDLL.440)
 145  */
 146 int CRTDLL_printf(DWORD *args)
 147 {
 148         /* CMF - This makes a BIG assumption about va_list */
 149         return vfprintf(stdout, (LPSTR) args[0], (va_list) &args[1]);
 150 }
 151
 152 /*********************************************************************
 153  *                  sprintf        (CRTDLL.458)
 154  */
 155 int CRTDLL_sprintf(DWORD *args)
 156 {
 157         /* CMF - This makes a BIG assumption about va_list */
 158         return vsprintf((LPSTR) args[0], (LPSTR) args[1], (va_list) &args[2]);
 159 }
 160
 161 /*********************************************************************
 162  *                  time          (CRTDLL.488)
 163  */
 164 time_t CRTDLL_time(time_t *timeptr)
 165 {
 166         time_t  curtime = time(NULL);
 167
 168         if (timeptr)
 169                 *timeptr = curtime;
 170         return curtime;
 171 }
 172
 173 /*********************************************************************
 174  *                  _isatty       (CRTDLL.137)
 175  */
 176 BOOL32 CRTDLL__isatty(DWORD x)
 177 {
 178         dprintf_crtdll(stderr,"CRTDLL__isatty(%ld)\n",x);
 179         return TRUE;
 180 }
 181
 182 /*********************************************************************
 183  *                  _write        (CRTDLL.332)
 184  */
 185 INT32 CRTDLL__write(DWORD x,LPVOID buf,DWORD len)
 186 {
 187         if (x<=2)
 188                 return write(x,buf,len);
 189         /* hmm ... */
 190         dprintf_crtdll(stderr,"CRTDLL__write(%ld,%p,%ld)\n",x,buf,len);
 191         return len;
 192 }
 193
 194
 195 /*********************************************************************
 196  *                  exit          (CRTDLL.359)
 197  */
 198 void CRTDLL_exit(DWORD ret)
 199 {
 200         dprintf_crtdll(stderr,"CRTDLL_exit(%ld)\n",ret);
 201         ExitProcess(ret);
 202 }
 203
 204
 205 /*********************************************************************
 206  *                  fflush        (CRTDLL.365)
 207  */
 208 void CRTDLL_fflush(DWORD x)
 209 {
 210     dprintf_crtdll(stderr,"CRTDLL_fflush(%ld)\n",x);
 211 }
 212
 213
 214 /*********************************************************************
 215  *                  gets          (CRTDLL.391)
 216  */
 217 LPSTR CRTDLL_gets(LPSTR buf)
 218 {
 219   /* BAD, for the whole WINE process blocks... just done this way to test
 220    * windows95's ftp.exe.
 221    */
 222     return gets(buf);
 223 }
 224
 225
 226 /*********************************************************************
 227  *                  abs           (CRTDLL.339)
 228  */
 229 INT32 CRTDLL_abs(INT32 x)
 230 {
 231     return abs(x);
 232 }
 233
 234
 235 /*********************************************************************
 236  *                  acos          (CRTDLL.340)
 237  */
 238 float CRTDLL_acos(float x)
 239 {
 240     return acos(x);
 241 }
 242
 243
 244 /*********************************************************************
 245  *                  asin          (CRTDLL.342)
 246  */
 247 float CRTDLL_asin(float x)
 248 {
 249     return asin(x);
 250 }
 251
 252
 253 /*********************************************************************
 254  *                  atan          (CRTDLL.343)
 255  */
 256 float CRTDLL_atan(float x)
 257 {
 258     return atan(x);
 259 }
 260
 261
 262 /*********************************************************************
 263  *                  atan2         (CRTDLL.344)
 264  */
 265 float CRTDLL_atan2(float x, float y)
 266 {
 267     return atan2(x,y);
 268 }
 269
 270
 271 /*********************************************************************
 272  *                  atof          (CRTDLL.346)
 273  */
 274 float CRTDLL_atof(LPCSTR x)
 275 {
 276     return atof(x);
 277 }
 278
 279
 280 /*********************************************************************
 281  *                  atoi          (CRTDLL.347)
 282  */
 283 INT32 CRTDLL_atoi(LPCSTR x)
 284 {
 285     return atoi(x);
 286 }
 287
 288
 289 /*********************************************************************
 290  *                  atol          (CRTDLL.348)
 291  */
 292 LONG CRTDLL_atol(LPCSTR x)
 293 {
 294     return atol(x);
 295 }
 296
 297
 298 /*********************************************************************
 299  *                  cos           (CRTDLL.354)
 300  */
 301 float CRTDLL_cos(float x)
 302 {
 303     return cos(x);
 304 }
 305
 306
 307 /*********************************************************************
 308  *                  cosh          (CRTDLL.355)
 309  */
 310 float CRTDLL_cosh(float x)
 311 {
 312     return cosh(x);
 313 }
 314
 315
 316 /*********************************************************************
 317  *                  exp           (CRTDLL.360)
 318  */
 319 float CRTDLL_exp(float x)
 320 {
 321     return exp(x);
 322 }
 323
 324
 325 /*********************************************************************
 326  *                  fabs          (CRTDLL.361)
 327  */
 328 float CRTDLL_fabs(float x)
 329 {
 330     return fabs(x);
 331 }
 332
 333
 334 /*********************************************************************
 335  *                  isalnum       (CRTDLL.394)
 336  */
 337 CHAR CRTDLL_isalnum(CHAR x)
 338 {
 339     return isalnum(x);
 340 }
 341
 342
 343 /*********************************************************************
 344  *                  isalpha       (CRTDLL.395)
 345  */
 346 CHAR CRTDLL_isalpha(CHAR x)
 347 {
 348     return isalpha(x);
 349 }
 350
 351
 352 /*********************************************************************
 353  *                  iscntrl       (CRTDLL.396)
 354  */
 355 CHAR CRTDLL_iscntrl(CHAR x)
 356 {
 357     return iscntrl(x);
 358 }
 359
 360
 361 /*********************************************************************
 362  *                  isdigit       (CRTDLL.397)
 363  */
 364 CHAR CRTDLL_isdigit(CHAR x)
 365 {
 366     return isdigit(x);
 367 }
 368
 369
 370 /*********************************************************************
 371  *                  isgraph       (CRTDLL.398)
 372  */
 373 CHAR CRTDLL_isgraph(CHAR x)
 374 {
 375     return isgraph(x);
 376 }
 377
 378
 379 /*********************************************************************
 380  *                  islower       (CRTDLL.400)
 381  */
 382 CHAR CRTDLL_islower(CHAR x)
 383 {
 384     return islower(x);
 385 }
 386
 387
 388 /*********************************************************************
 389  *                  isprint       (CRTDLL.401)
 390  */
 391 CHAR CRTDLL_isprint(CHAR x)
 392 {
 393     return isprint(x);
 394 }
 395
 396
 397 /*********************************************************************
 398  *                  ispunct       (CRTDLL.402)
 399  */
 400 CHAR CRTDLL_ispunct(CHAR x)
 401 {
 402     return ispunct(x);
 403 }
 404
 405
 406 /*********************************************************************
 407  *                  isspace       (CRTDLL.403)
 408  */
 409 CHAR CRTDLL_isspace(CHAR x)
 410 {
 411     return isspace(x);
 412 }
 413
 414
 415 /*********************************************************************
 416  *                  isupper       (CRTDLL.404)
 417  */
 418 CHAR CRTDLL_isupper(CHAR x)
 419 {
 420     return isupper(x);
 421 }
 422
 423
 424 /*********************************************************************
 425  *                  isxdigit      (CRTDLL.418)
 426  */
 427 CHAR CRTDLL_isxdigit(CHAR x)
 428 {
 429     return isxdigit(x);
 430 }
 431
 432
 433 /*********************************************************************
 434  *                  labs          (CRTDLL.419)
 435  */
 436 LONG CRTDLL_labs(LONG x)
 437 {
 438     return labs(x);
 439 }
 440
 441
 442 /*********************************************************************
 443  *                  log           (CRTDLL.424)
 444  */
 445 float CRTDLL_log(float x)
 446 {
 447     return log(x);
 448 }
 449
 450
 451 /*********************************************************************
 452  *                  log10         (CRTDLL.425)
 453  */
 454 float CRTDLL_log10(float x)
 455 {
 456     return log10(x);
 457 }
 458
 459
 460 /*********************************************************************
 461  *                  pow           (CRTDLL.439)
 462  */
 463 float CRTDLL_pow(float x, float y)
 464 {
 465     return pow(x,y);
 466 }
 467
 468
 469 /*********************************************************************
 470  *                  rand          (CRTDLL.446)
 471  */
 472 INT32 CRTDLL_rand()
 473 {
 474     return rand();
 475 }
 476
 477
 478 /*********************************************************************
 479  *                  sin           (CRTDLL.456)
 480  */
 481 float CRTDLL_sin(float x)
 482 {
 483     return sin(x);
 484 }
 485
 486
 487 /*********************************************************************
 488  *                  sinh          (CRTDLL.457)
 489  */
 490 float CRTDLL_sinh(float x)
 491 {
 492     return sinh(x);
 493 }
 494
 495
 496 /*********************************************************************
 497  *                  sqrt          (CRTDLL.459)
 498  */
 499 float CRTDLL_sqrt(float x)
 500 {
 501     return sqrt(x);
 502 }
 503
 504
 505 /*********************************************************************
 506  *                  tan           (CRTDLL.486)
 507  */
 508 float CRTDLL_tan(float x)
 509 {
 510     return tan(x);
 511 }
 512
 513
 514 /*********************************************************************
 515  *                  tanh          (CRTDLL.487)
 516  */
 517 float CRTDLL_tanh(float x)
 518 {
 519     return tanh(x);
 520 }
 521
 522
 523 /*********************************************************************
 524  *                  tolower       (CRTDLL.491)
 525  */
 526 CHAR CRTDLL_tolower(CHAR x)
 527 {
 528     return tolower(x);
 529 }
 530
 531
 532 /*********************************************************************
 533  *                  toupper       (CRTDLL.492)
 534  */
 535 CHAR CRTDLL_toupper(CHAR x)
 536 {
 537     return toupper(x);
 538 }
 539
 540
 541 /*********************************************************************
 542  *                  putchar       (CRTDLL.442)
 543  */
 544 void CRTDLL_putchar(INT32 x)
 545 {
 546     putchar(x);
 547 }
 548
 549
 550 /*********************************************************************
 551  *                  _mbsicmp      (CRTDLL.204)
 552  */
 553 int CRTDLL__mbsicmp(unsigned char *x,unsigned char *y)
 554 {
 555     do {
 556         if (!*x)
 557             return !!*y;
 558         if (!*y)
 559             return !!*x;
 560         /* FIXME: MBCS handling... */
 561         if (*x!=*y)
 562             return 1;
 563         x++;
 564         y++;
 565     } while (1);
 566 }
 567
 568
 569 /*********************************************************************
 570  *                  _mbsinc       (CRTDLL.205)
 571  */
 572 unsigned char* CRTDLL__mbsinc(unsigned char *x)
 573 {
 574     /* FIXME: mbcs */
 575     return x++;
 576 }
 577
 578
 579 /*********************************************************************
 580  *                  vsprintf      (CRTDLL.500)
 581  */
 582 int CRTDLL_vsprintf(DWORD *args)
 583 {
 584         /* CMF - This makes a BIG assumption about va_list */
 585         return vsprintf((char *) args[0], (char *) args[1], (va_list) &args[2]);
 586 }
 587
 588 /*********************************************************************
 589  *                  vsprintf      (CRTDLL.500) (NTDLL.913)
 590  */
 591 int CRTDLL_sscanf(DWORD *args)
 592 {
 593         /* CMF - This makes a BIG assumption about va_list */
 594         return vsscanf((char *) args[0], (char *) args[1], (va_list) &args[2]);
 595 }
 596
 597
 598 /*********************************************************************
 599  *                  _mbscpy       (CRTDLL.200)
 600  */
 601 unsigned char* CRTDLL__mbscpy(unsigned char *x,unsigned char *y)
 602 {
 603     return strcpy(x,y);
 604 }
 605
 606
 607 /*********************************************************************
 608  *                  _mbscat       (CRTDLL.197)
 609  */
 610 unsigned char* CRTDLL__mbscat(unsigned char *x,unsigned char *y)
 611 {
 612     return strcat(x,y);
 613 }
 614
 615 /*********************************************************************
 616  *                  _strupr       (CRTDLL.300)
 617  */
 618 LPSTR CRTDLL__strupr(LPSTR x)
 619 {
 620         LPSTR   y=x;
 621
 622         while (*y) {
 623                 *y=toupper(*y);
 624                 y++;
 625         }
 626         return x;
 627 }
 628
 629 /*********************************************************************
 630  *                  _wcsupr       (CRTDLL.328)
 631  */
 632 LPWSTR CRTDLL__wcsupr(LPWSTR x)
 633 {
 634         LPWSTR  y=x;
 635
 636         while (*y) {
 637                 *y=toupper(*y);
 638                 y++;
 639         }
 640         return x;
 641 }
 642
 643 /*********************************************************************
 644  *                  _wcslwr       (CRTDLL.323)
 645  */
 646 LPWSTR CRTDLL__wcslwr(LPWSTR x)
 647 {
 648         LPWSTR  y=x;
 649
 650         while (*y) {
 651                 *y=tolower(*y);
 652                 y++;
 653         }
 654         return x;
 655 }
 656
 657
 658 /*********************************************************************
 659  *                  malloc        (CRTDLL.427)
 660  */
 661 VOID* CRTDLL_malloc(DWORD size)
 662 {
 663     return HeapAlloc(GetProcessHeap(),0,size);
 664 }
 665
 666 /*********************************************************************
 667  *                  new           (CRTDLL.001)
 668  */
 669 VOID* CRTDLL_new(DWORD size)
 670 {
 671     VOID* result;
 672     if(!(result = HeapAlloc(GetProcessHeap(),0,size)) && new_handler)
 673         (*new_handler)();
 674     return result;
 675 }
 676
 677 /*********************************************************************
 678  *                  set_new_handler(CRTDLL.003)
 679  */
 680 new_handler_type CRTDLL_set_new_handler(new_handler_type func)
 681 {
 682     new_handler_type old_handler = new_handler;
 683     new_handler = func;
 684     return old_handler;
 685 }
 686
 687 /*********************************************************************
 688  *                  calloc        (CRTDLL.350)
 689  */
 690 VOID* CRTDLL_calloc(DWORD size, DWORD count)
 691 {
 692     return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size * count );
 693 }
 694
 695 /*********************************************************************
 696  *                  realloc        (CRTDLL.447)
 697  */
 698 VOID* CRTDLL_realloc( VOID *ptr, DWORD size )
 699 {
 700     return HeapReAlloc( GetProcessHeap(), 0, ptr, size );
 701 }
 702
 703 /*********************************************************************
 704  *                  free          (CRTDLL.427)
 705  */
 706 VOID CRTDLL_free(LPVOID ptr)
 707 {
 708     HeapFree(GetProcessHeap(),0,ptr);
 709 }
 710
 711 /*********************************************************************
 712  *                  delete       (CRTDLL.002)
 713  */
 714 VOID CRTDLL_delete(VOID* ptr)
 715 {
 716     HeapFree(GetProcessHeap(),0,ptr);
 717 }
 718
 719 /*********************************************************************
 720  *                  _strdup          (CRTDLL.285)
 721  */
 722 LPSTR CRTDLL__strdup(LPSTR ptr)
 723 {
 724     return HEAP_strdupA(GetProcessHeap(),0,ptr);
 725 }
 726
 727 /*********************************************************************
 728  *                  fclose           (CRTDLL.362)
 729  */
 730 DWORD CRTDLL_fclose(LPVOID x)
 731 {
 732     dprintf_crtdll(stdnimp,"fclose(%p)\n",x);
 733     return 0;
 734 }
 735
 736 /*********************************************************************
 737  *                  setlocale           (CRTDLL.453)
 738  */
 739 LPSTR CRTDLL_setlocale(INT32 category,LPCSTR locale)
 740 {
 741         LPSTR categorystr;
 742
 743         switch (category) {
 744         case CRTDLL_LC_ALL: categorystr="LC_ALL";break;
 745         case CRTDLL_LC_COLLATE: categorystr="LC_COLLATE";break;
 746         case CRTDLL_LC_CTYPE: categorystr="LC_CTYPE";break;
 747         case CRTDLL_LC_MONETARY: categorystr="LC_MONETARY";break;
 748         case CRTDLL_LC_NUMERIC: categorystr="LC_NUMERIC";break;
 749         case CRTDLL_LC_TIME: categorystr="LC_TIME";break;
 750         default: categorystr = "UNKNOWN?";break;
 751         }
 752         fprintf(stderr,"CRTDLL.setlocale(%s,%s),stub!\n",categorystr,locale);
 753         return "C";
 754 }
 755
 756 /*********************************************************************
 757  *                  wcsspn           (CRTDLL.516)
 758  */
 759 INT32 CRTDLL_wcsspn(LPWSTR str,LPWSTR accept)
 760 {
 761         LPWSTR  s,t;
 762
 763         s=str;
 764         do {
 765                 t=accept;
 766                 while (*t) { if (*t==*s) break;t++;}
 767                 if (!*t) break;
 768                 s++;
 769         } while (*s);
 770         return s-str; /* nr of wchars */
 771 }
 772
 773 /*********************************************************************
 774  *                  wcscspn           (CRTDLL.508)
 775  */
 776 INT32 CRTDLL_wcscspn(LPWSTR str,LPWSTR reject)
 777 {
 778         LPWSTR  s,t;
 779
 780         s=str;
 781         do {
 782                 t=reject;
 783                 while (*t) { if (*t==*s) break;t++;}
 784                 if (*t) break;
 785                 s++;
 786         } while (*s);
 787         return s-str; /* nr of wchars */
 788 }
 789
 790 /*********************************************************************
 791  *                  wcschr           (CRTDLL.504)
 792  */
 793 LPWSTR CRTDLL_wcschr(LPWSTR str,WCHAR xchar)
 794 {
 795         LPWSTR  s;
 796
 797         s=str;
 798         do {
 799                 if (*s==xchar)
 800                         return s;
 801         } while (*s++);
 802         return NULL;
 803 }
 804
 805 /*********************************************************************
 806  *                  towupper           (CRTDLL.494)
 807  */
 808 WCHAR CRTDLL_towupper(WCHAR x)
 809 {
 810     return (WCHAR)toupper((CHAR)x);
 811 }
 812
 813 /*********************************************************************
 814  *                  swprintf           (CRTDLL.483)
 815  */
 816 DWORD CRTDLL_swprintf(DWORD *args)
 817 {
 818     return WIN32_wsprintf32W(args);
 819 }
 820
 821 /*********************************************************************
 822  *                  _wcsicoll           (CRTDLL.322)
 823  */
 824 DWORD CRTDLL__wcsicoll(LPWSTR a1,LPWSTR a2)
 825 {
 826     /* FIXME: handle collates */
 827     return lstrcmpi32W(a1,a2);
 828 }
 829
 830 /*********************************************************************
 831  *                  wcscoll           (CRTDLL.506)
 832  */
 833 DWORD CRTDLL_wcscoll(LPWSTR a1,LPWSTR a2)
 834 {
 835     /* FIXME: handle collates */
 836     return lstrcmp32W(a1,a2);
 837 }
 838
 839 /*********************************************************************
 840  *                  _wcsrev           (CRTDLL.326)
 841  */
 842 VOID CRTDLL__wcsrev(LPWSTR s) {
 843         LPWSTR  e;
 844
 845         e=s;
 846         while (*e)
 847                 e++;
 848         while (s<e) {
 849                 WCHAR   a;
 850
 851                 a=*s;*s=*e;*e=a;
 852                 s++;e--;
 853         }
 854 }
 855
 856 /*********************************************************************
 857  *                  wcsstr           (CRTDLL.517)
 858  */
 859 LPWSTR CRTDLL_wcsstr(LPWSTR s,LPWSTR b)
 860 {
 861         LPWSTR  x,y,c;
 862
 863         x=s;
 864         while (*x) {
 865                 if (*x==*b) {
 866                         y=x;c=b;
 867                         while (*y && *c && *y==*c) { c++;y++; }
 868                         if (!*c)
 869                                 return x;
 870                 }
 871                 x++;
 872         }
 873         return NULL;
 874 }
 875
 876 /*********************************************************************
 877  *                  wcsrchr           (CRTDLL.515)
 878  */
 879 LPWSTR CRTDLL_wcsrchr(LPWSTR str,WCHAR xchar)
 880 {
 881         LPWSTR  s;
 882
 883         s=str+lstrlen32W(str);
 884         do {
 885                 if (*s==xchar)
 886                         return s;
 887                 s--;
 888         } while (s>=str);
 889         return NULL;
 890 }
 891
 892 /*********************************************************************
 893  *                  _setmode           (CRTDLL.265)
 894  * FIXME: dunno what this is.
 895  */
 896 DWORD
 897 CRTDLL__setmode(LPVOID x,INT32 y) {
 898         /* FIXME */
 899         fprintf(stdnimp,"CRTDLL._setmode(%p,%d), STUB.\n",x,y);
 900         return 0;
 901 }
 902
 903 /*********************************************************************
 904  *                  atexit           (CRTDLL.345)
 905  */
 906 INT32
 907 CRTDLL_atexit(LPVOID x) {
 908         /* FIXME */
 909         fprintf(stdnimp,"CRTDLL.atexit(%p), STUB.\n",x);
 910         return 0; /* successful */
 911 }
 912
 913 /*********************************************************************
 914  *                  mbtowc           (CRTDLL.430)
 915  * FIXME: check multibyte support
 916  */
 917 WCHAR
 918 CRTDLL_mbtowc(CHAR a) {
 919         return a;
 920 }
 921
 922 /*********************************************************************
 923  *                  _isctype           (CRTDLL.138)
 924  */
 925 BOOL32
 926 CRTDLL__isctype(CHAR x,CHAR type) {
 927         if ((type & CRTDLL_SPACE) && isspace(x))
 928                 return TRUE;
 929         if ((type & CRTDLL_PUNCT) && ispunct(x))
 930                 return TRUE;
 931         if ((type & CRTDLL_LOWER) && islower(x))
 932                 return TRUE;
 933         if ((type & CRTDLL_UPPER) && isupper(x))
 934                 return TRUE;
 935         if ((type & CRTDLL_ALPHA) && isalpha(x))
 936                 return TRUE;
 937         if ((type & CRTDLL_DIGIT) && isdigit(x))
 938                 return TRUE;
 939         if ((type & CRTDLL_CONTROL) && iscntrl(x))
 940                 return TRUE;
 941         /* check CRTDLL_LEADBYTE */
 942         return FALSE;
 943 }
 944
 945 /*********************************************************************
 946  *                  _chdrive           (CRTDLL.52)
 947  */
 948 BOOL32
 949 CRTDLL__chdrive(INT32 newdrive) {
 950         /* FIXME: generates errnos */
 951         return DRIVE_SetCurrentDrive(newdrive);
 952 }
 953
 954 /*********************************************************************
 955  *                  _chdir           (CRTDLL.51)
 956  */
 957 INT32
 958 CRTDLL__chdir(LPCSTR newdir) {
 959         if (!SetCurrentDirectory32A(newdir))
 960                 return -1;
 961         return 0;
 962 }
 963
 964 /*********************************************************************
 965  *                  _mkdir           (CRTDLL.234)
 966  */
 967 INT32
 968 CRTDLL__mkdir(LPCSTR newdir) {
 969         if (!CreateDirectory32A(newdir,NULL))
 970                 return -1;
 971         return 0;
 972 }
 973
 974 /*********************************************************************
 975  *                  _errno           (CRTDLL.52)
 976  * Yes, this is a function.
 977  */
 978 LPINT32
 979 CRTDLL__errno() {
 980         static  int crtdllerrno;
 981         extern int LastErrorToErrno(DWORD);
 982
 983         /* FIXME: we should set the error at the failing function call time */
 984         crtdllerrno = LastErrorToErrno(GetLastError());
 985         return &crtdllerrno;
 986 }