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