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