Ignore:
Timestamp:
Sep 13, 1999, 11:05:13 AM (26 years ago)
Author:
sandervl
Message:

* empty log message *

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/crtdll/crtdll.cpp

    r864 r916  
    1 /* $Id: crtdll.cpp,v 1.1 1999-09-07 20:41:44 sandervl Exp $ */
     1/* $Id: crtdll.cpp,v 1.2 1999-09-13 09:05:13 sandervl Exp $ */
    22
    33/*
    … …  
    2828#include <wchar.h>
    2929#include <wctype.h>
     30#include <math.h>
     31#include <locale.h>
     32#include <signal.h>
    3033
    3134#include <crtdll.h>
    … …  
    147150
    148151/*********************************************************************
     152 *                  _aexit_rtn_dll    (CRTDLL.39)
     153 *      FIXME - Could not find anything about it
     154 */
     155INT CDECL CRTDLL__aexit_rtn_dll(DWORD ret)
     156{
     157        dprintf(("CRTDLL: _aexit_rtn_dll\n"));
     158
     159        return 0;
     160}
     161
     162/*********************************************************************
     163 *                  _amsg_exit    (CRTDLL.40)
     164 *      FIXME - Could not find anything about it
     165 */
     166INT CDECL CRTDLL__amsg_exit(DWORD ret)
     167{
     168        dprintf(("CRTDLL: _amsg_exit\n"));
     169
     170        return 0;
     171}
     172
     173/*********************************************************************
    149174 *                  _chdir           (CRTDLL.51)
    150175 */
    … …  
    154179        if (!SetCurrentDirectoryA(newdir))
    155180                return 1;
     181        return 0;
     182}
     183
     184/*********************************************************************
     185 *                  _except_handler2    (CRTDLL.78)
     186 *      FIXME - Could not find anything about it
     187 */
     188INT CDECL CRTDLL__except_handler2(DWORD ret)
     189{
     190        dprintf(("CRTDLL: _except_handler2\n"));
     191
    156192        return 0;
    157193}
    … …  
    325361}
    326362
    327 /*********************************************************************
    328  *                  _memicmp           (CRTDLL.233)
    329  * A stringcompare, without \0 check
    330  * RETURNS
    331  *      -1:if first string is alphabetically before second string
    332  *      1:if second ''    ''      ''          ''   first   ''
    333  *      0:if both are equal.
    334  */
    335 INT CDECL CRTDLL__memicmp(
    336         LPCSTR s1,      /* [in] first string */
    337         LPCSTR s2,      /* [in] second string */
    338         DWORD len       /* [in] length to compare */
    339 ) {
    340         dprintf(("CRTDLL: memicmp\n"));
    341         int     i;
    342 
    343         for (i=0;i<len;i++) {
    344                 if (tolower(s1[i])<tolower(s2[i]))
    345                         return -1;
    346                 if (tolower(s1[i])>tolower(s2[i]))
    347                         return  1;
    348         }
    349         return 0;
    350 }
    351363
    352364/*********************************************************************
    … …  
    375387
    376388/*********************************************************************
    377  *                  _strnicmp   (CRTDLL.291)
    378  */
    379 INT CDECL CRTDLL__strnicmp( LPCSTR s1, LPCSTR s2, INT n )
    380 {
    381     dprintf(("CRTDLL: strnicmp\n"));
    382     return lstrncmpiA( s1, s2, n );
    383 }
    384 
    385 /*********************************************************************
    386389 *           CRTDLL__wcsnset    (CRTDLL.322)
    387390 */
    … …  
    404407
    405408/*********************************************************************
     409 *                  isleadbyte  (CRTDLL.335)
     410 */
     411void CDECL CRTDLL_abort( void )
     412{
     413  dprintf(("CRTDLL: abort\n"));
     414  abort();
     415}
     416
     417/*********************************************************************
     418 *                  acos        (CRTDLL.336)
     419 */
     420double CDECL CRTDLL_acos( double x )
     421{
     422  dprintf(("CRTDLL: acos\n"));
     423  return (acos(x));
     424}
     425
     426/*********************************************************************
     427 *                  asctime     (CRTDLL.338)
     428 */
     429char * CDECL CRTDLL_asctime( const struct tm *timeptr )
     430{
     431  dprintf(("CRTDLL: asctime\n"));
     432  return (asctime(timeptr));
     433}
     434
     435/*********************************************************************
     436 *                  asin        (CRTDLL.339)
     437 */
     438double CDECL CRTDLL_asin( double x )
     439{
     440  dprintf(("CRTDLL: asin\n"));
     441  return (asin(x));
     442}
     443
     444/*********************************************************************
     445 *                  atan2       (CRTDLL.341)
     446 */
     447double CDECL CRTDLL_atan2( double y, double x )
     448{
     449  dprintf(("CRTDLL: atan2\n"));
     450  return (atan2(y, x));
     451}
     452
     453/*********************************************************************
     454 *                  atexit      (CRTDLL.342)
     455 */
     456int CDECL CRTDLL_atexit( register void ( *func )( void ) )
     457{
     458  dprintf(("CRTDLL: atexit\n"));
     459  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     460  return FALSE;
     461}
     462
     463/*********************************************************************
     464 *                  atof        (CRTDLL.343)
     465 */
     466double CDECL CRTDLL_atof( const char *nptr )
     467{
     468  dprintf(("CRTDLL: atof\n"));
     469  return (atof(nptr));
     470}
     471
     472/*********************************************************************
     473 *                  bsearch     (CRTDLL.346)
     474 */
     475void * CDECL CRTDLL_bsearch( const void *key, const void *base,  size_t nmemb,
     476         size_t size, int (*compar)(const void *pkey, const void *pbase) )
     477{
     478  dprintf(("CRTDLL: bsearch\n"));
     479  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     480  return FALSE;
     481}
     482
     483/*********************************************************************
     484 *                  calloc      (CRTDLL.347)
     485 */
     486void * CDECL CRTDLL_calloc( size_t n, size_t size )
     487{
     488  dprintf(("CRTDLL: calloc\n"));
     489  return (calloc(n, size));
     490}
     491
     492/*********************************************************************
     493 *                  clearerr    (CRTDLL.349)
     494 */
     495void CDECL CRTDLL_clearerr( FILE *fp )
     496{
     497  dprintf(("CRTDLL: clearerr\n"));
     498  clearerr(fp);
     499}
     500
     501/*********************************************************************
     502 *                  clock       (CRTDLL.350)
     503 */
     504clock_t CDECL CRTDLL_clock( void )
     505{
     506  dprintf(("CRTDLL: clock\n"));
     507  return (clock());
     508}
     509
     510/*********************************************************************
     511 *                  cosh        (CRTDLL.352)
     512 */
     513double CDECL CRTDLL_cosh( double x )
     514{
     515  dprintf(("CRTDLL: cosh\n"));
     516  return (cosh(x));
     517}
     518
     519/*********************************************************************
     520 *                  ctime       (CRTDLL.353)
     521 */
     522char * CDECL CRTDLL_ctime( const time_t *timer )
     523{
     524  dprintf(("CRTDLL: ctime\n"));
     525  return (ctime(timer));
     526}
     527
     528/*********************************************************************
     529 *                  difftime    (CRTDLL.354)
     530 */
     531double CDECL CRTDLL_difftime( time_t t1, time_t t0 )
     532{
     533  dprintf(("CRTDLL: difftime\n"));
     534  return (difftime(t1, t0));
     535}
     536
     537/*********************************************************************
     538 *                  div         (CRTDLL.355)
     539 */
     540div_t CDECL CRTDLL_div( int numer, int denom )
     541{
     542  dprintf(("CRTDLL: div\n"));
     543  return (div(numer, denom));
     544}
     545
     546/*********************************************************************
    406547 *                  exit          (CRTDLL.356)
    407548 */
    … …  
    410551        dprintf(("CRTDLL: exit\n"));
    411552        ExitProcess(ret);
     553}
     554
     555/*********************************************************************
     556 *                  exp         (CRTDLL.357)
     557 */
     558double CDECL CRTDLL_exp( double x )
     559{
     560  dprintf(("CRTDLL: exp\n"));
     561  return (exp(x));
     562}
     563
     564/*********************************************************************
     565 *                  fclose      (CRTDLL.359)
     566 */
     567int CDECL CRTDLL_fclose( FILE *fp )
     568{
     569  dprintf(("CRTDLL: fclose\n"));
     570  return (fclose(fp));
     571}
     572
     573/*********************************************************************
     574 *                  feof        (CRTDLL.360)
     575 */
     576int CDECL CRTDLL_feof( FILE *fp )
     577{
     578  dprintf(("CRTDLL: feof\n"));
     579  return (feof(fp));
     580}
     581
     582/*********************************************************************
     583 *                  ferror      (CRTDLL.361)
     584 */
     585int CDECL CRTDLL_ferror( FILE *fp )
     586{
     587  dprintf(("CRTDLL: ferror\n"));
     588  return (ferror(fp));
     589}
     590
     591/*********************************************************************
     592 *                  fflush      (CRTDLL.362)
     593 */
     594int CDECL CRTDLL_fflush( FILE *fp )
     595{
     596  dprintf(("CRTDLL: fflush\n"));
     597  return (fflush(fp));
     598}
     599
     600/*********************************************************************
     601 *                  fgetc       (CRTDLL.363)
     602 */
     603int CDECL CRTDLL_fgetc( FILE *fp )
     604{
     605  dprintf(("CRTDLL: fgetc\n"));
     606  return (fgetc(fp));
     607}
     608
     609/*********************************************************************
     610 *                  fgetpos     (CRTDLL.364)
     611 */
     612int CDECL CRTDLL_fgetpos( FILE *fp, fpos_t *pos )
     613{
     614  dprintf(("CRTDLL: fgetpos\n"));
     615  return (fgetpos(fp, pos));
     616}
     617
     618/*********************************************************************
     619 *                  fgets       (CRTDLL.365)
     620 */
     621char * CDECL CRTDLL_fgets( char *s, int n, FILE *fp )
     622{
     623  dprintf(("CRTDLL: fgets\n"));
     624  return (fgets(s, n, fp));
     625}
     626
     627/*********************************************************************
     628 *                  fgetwc      (CRTDLL.366)
     629 */
     630wint_t CDECL CRTDLL_fgetwc( FILE *f )
     631{
     632  dprintf(("CRTDLL: fgetwc\n"));
     633  return (fgetwc(f));
     634}
     635
     636/*********************************************************************
     637 *                  fmod        (CRTDLL.368)
     638 */
     639double CDECL CRTDLL_fmod(double x, double y )
     640{
     641  dprintf(("CRTDLL: fmod\n"));
     642  return (fmod(x,y));
     643}
     644
     645/*********************************************************************
     646 *                  fopen       (CRTDLL.369)
     647 */
     648FILE * CDECL CRTDLL_fopen( const char *filename, const char *mode )
     649{
     650  dprintf(("CRTDLL: fopen\n"));
     651  return (fopen( filename, mode));
    412652}
    413653
    … …  
    428668
    429669/*********************************************************************
     670 *                  fputc   (CRTDLL.371)
     671 */
     672int CDECL CRTDLL_fputc( int c, FILE *fp )
     673{
     674  dprintf(("CRTDLL: fputc\n"));
     675  return (fputc(c, fp));
     676}
     677
     678/*********************************************************************
     679 *                  fputs   (CRTDLL.372)
     680 */
     681int CDECL CRTDLL_fputs( const char *s, FILE *fp )
     682{
     683  dprintf(("CRTDLL: fputs\n"));
     684  return (fputs(s, fp));
     685}
     686
     687/*********************************************************************
     688 *                  fputwc  (CRTDLL.373)
     689 */
     690wint_t CDECL CRTDLL_fputwc( wint_t wc, FILE *strm )
     691{
     692  dprintf(("CRTDLL: fputwc\n"));
     693  return (fputwc(wc, strm));
     694}
     695
     696/*********************************************************************
     697 *                  fread  (CRTDLL.374)
     698 */
     699size_t CDECL CRTDLL_fread( void *ptr, size_t size, size_t n, FILE *fp )
     700{
     701  dprintf(("CRTDLL: fread\n"));
     702  return (fread(ptr, size, n, fp));
     703}
     704 
     705/*********************************************************************
    430706 *                  free          (CRTDLL.375)
    431707 */
    … …  
    434710    dprintf(("CRTDLL: free\n"));
    435711    HeapFree(GetProcessHeap(),0,ptr);
     712}
     713
     714/*********************************************************************
     715 *                  freopen       (CRTDLL.376)
     716 */
     717FILE * CDECL CRTDLL_freopen( const char *filename, const char *mode, FILE *fp )
     718{
     719  dprintf(("CRTDLL: freopen\n"));
     720  return (freopen(filename, mode, fp));
     721}
     722
     723/*********************************************************************
     724 *                  frexp         (CRTDLL.377)
     725 */
     726double CDECL CRTDLL_frexp( double value, int *exp )
     727{
     728  dprintf(("CRTDLL: frexp\n"));
     729  return (frexp(value, exp));
     730}
     731
     732/*********************************************************************
     733 *                  fscanf        (CRTDLL.378)
     734 */
     735int CDECL CRTDLL_fscanf( FILE*fp, const char *format, ... )
     736{
     737  dprintf(("CRTDLL: frexp\n"));
     738  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     739  return FALSE;
     740}
     741
     742/*********************************************************************
     743 *                  fseek         (CRTDLL.379)
     744 */
     745int CDECL CRTDLL_fseek( FILE *fp, long int offset, int whence )
     746{
     747  dprintf(("CRTDLL: fseek\n"));
     748  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     749  return FALSE;
     750}
     751
     752/*********************************************************************
     753 *                  fsetpos       (CRTDLL.380)
     754 */
     755int CDECL CRTDLL_fsetpos( FILE *fp, const fpos_t *pos )
     756{
     757  dprintf(("CRTDLL: fsetpos\n"));
     758  return (fsetpos(fp, pos));
     759}
     760
     761/*********************************************************************
     762 *                  ftell         (CRTDLL.381)
     763 */
     764long int CDECL CRTDLL_ftell( FILE *fp )
     765{
     766  dprintf(("CRTDLL: ftell\n"));
     767  return (ftell(fp));
     768}
     769
     770/*********************************************************************
     771 *                  fwprintf      (CRTDLL.382)
     772 */
     773int CDECL CRTDLL_fwprintf( FILE *strm, const wchar_t *format, ... )
     774{
     775  dprintf(("CRTDLL: fwprintf\n"));
     776  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     777  return FALSE;
    436778}
    437779
    … …  
    449791
    450792/*********************************************************************
     793 *                  fwscanf       (CRTDLL.384)
     794 */
     795int CDECL CRTDLL_fwscanf( FILE *strm, const wchar_t *format, ... )
     796{
     797  dprintf(("CRTDLL: fwscanf\n"));
     798  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     799  return FALSE;
     800}
     801
     802/*********************************************************************
     803 *                  getc    (CRTDLL.385)
     804 */
     805int CDECL CRTDLL_getc( FILE *fp )
     806{
     807  dprintf(("CRTDLL: getc\n"));
     808  return (getc(fp));
     809}
     810
     811/*********************************************************************
     812 *                  getchar    (CRTDLL.386)
     813 */
     814int CDECL CRTDLL_getchar( void )
     815{
     816  dprintf(("CRTDLL: getchar\n"));
     817  return (getchar());
     818}
     819
     820/*********************************************************************
     821 *                  getenv    (CRTDLL.387)
     822 */
     823char * CDECL CRTDLL_getenv( const char *name )
     824{
     825  dprintf(("CRTDLL: getenv\n"));
     826  return (getenv(name));
     827}
     828
     829/*********************************************************************
     830 *                  gets    (CRTDLL.388)
     831 */
     832char * CDECL CRTDLL_gets( char *s )
     833{
     834  dprintf(("CRTDLL: gets\n"));
     835  return (gets(s));
     836}
     837
     838/*********************************************************************
     839 *                  gmtime    (CRTDLL.389)
     840 */
     841struct tm * CDECL CRTDLL_gmtime( const time_t *timer )
     842{
     843  dprintf(("CRTDLL: gmtime\n"));
     844  return (gmtime(timer));
     845}
     846
     847/*********************************************************************
     848 *                  is_wctype    (CRTDLL.390)
     849 *      FIXME - Could not find anything about it
     850 */
     851INT CDECL CRTDLL_is_wctype(DWORD ret)
     852{
     853        dprintf(("CRTDLL: is_wctype\n"));
     854        return 0;
     855}
     856
     857/*********************************************************************
    451858 *                  isalnum    (CRTDLL.391)
    452859 */
    … …  
    454861{
    455862  dprintf(("CRTDLL: isalnum(%08xh)\n", i));
    456 
    457863  return (isalnum(i));
    458864}
    … …  
    464870{
    465871  dprintf(("CRTDLL: iscntrl(%08xh)\n", i));
    466 
    467872  return (iscntrl(i));
    468873}
    … …  
    474879{
    475880  dprintf(("CRTDLL: isgraph(%08xh)\n", i));
    476 
    477881  return (isgraph(i));
    478882}
    … …  
    484888{
    485889  dprintf(("CRTDLL: isleadbyte(%08xh)\n", i));
    486 
    487890  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    488891  return FALSE;
    … …  
    495898{
    496899  dprintf(("CRTDLL: ispunct(%08xh)\n", i));
    497 
    498900  return (ispunct(i));
    499901}
    … …  
    510912
    511913/*********************************************************************
    512  *                  iswalpha    (CRTDLL.403)
    513  */
    514 int CDECL CRTDLL_iswalpha(wint_t i)
    515 {
    516   dprintf(("CRTDLL: iswalpha(%08xh)\n", i));
    517 
    518   return (iswalpha(i));
    519 }
    520 
    521 /*********************************************************************
    522914 *                  iswascii    (CRTDLL.404)
    523915 */
    … …  
    541933
    542934/*********************************************************************
    543  *                  iswctype    (CRTDLL.406)
    544  */
    545 int CDECL CRTDLL_iswctype(wint_t i, wctype_t wct)
    546 {
    547   dprintf(("CRTDLL: iswctype\n"));
    548 
    549   return (iswctype(i, wct));
    550 }
    551 
    552 /*********************************************************************
    553935 *                  iswdigit    (CRTDLL.407)
    554936 */
    … …  
    6311013
    6321014/*********************************************************************
    633  *                  isxdigit    (CRTDLL.415)
    634  */
    635 int CDECL CRTDLL_isxdigit(int i)
    636 {
    637   dprintf(("CRTDLL: isxdigit(%08xh)\n", i));
    638 
    639   return (isxdigit(i));
     1015 *                  ldexp       (CRTDLL.417)
     1016 */
     1017double CDECL CRTDLL_ldexp( double x, int exp )
     1018{
     1019  dprintf(("CRTDLL: ldexp\n"));
     1020
     1021  return (ldexp(x, exp));
     1022}
     1023
     1024/*********************************************************************
     1025 *                  ldiv        (CRTDLL.418)
     1026 */
     1027ldiv_t CDECL CRTDLL_ldiv( long int numer, long int denom )
     1028{
     1029  dprintf(("CRTDLL: ldiv\n"));
     1030
     1031  return (ldiv(numer, denom));
     1032}
     1033
     1034/*********************************************************************
     1035 *                  localeconv  (CRTDLL.419)
     1036 */
     1037struct lconv * CDECL CRTDLL_localeconv(void)
     1038{
     1039  dprintf(("CRTDLL: localeconv\n"));
     1040  return (localeconv());
     1041}
     1042
     1043/*********************************************************************
     1044 *                  localtime   (CRTDLL.420)
     1045 */
     1046struct tm * CDECL CRTDLL_localtime( const time_t *timer )
     1047{
     1048  dprintf(("CRTDLL: localtime\n"));
     1049  return (localtime(timer));
     1050}
     1051
     1052/*********************************************************************
     1053 *                  log10       (CRTDLL.422)
     1054 */
     1055double CDECL CRTDLL_log10( double x )
     1056{
     1057  dprintf(("CRTDLL: log10\n"));
     1058  return (log10(x));
    6401059}
    6411060
    … …  
    6561075      dprintf(("CRTDLL: malloc\n"));
    6571076      return HeapAlloc(GetProcessHeap(),0,size);
     1077}
     1078
     1079/*********************************************************************
     1080 *                  mblen        (CRTDLL.425)
     1081 */
     1082INT CDECL CRTDLL_mblen( const char *s, size_t n )
     1083{
     1084      dprintf(("CRTDLL: mblen\n"));
     1085      return (mblen(s, n));
    6581086}
    6591087
    … …  
    6701098
    6711099/*********************************************************************
    672  *                  memcmp   (CRTDLL.429)
    673  */
    674 int CDECL CRTDLL_memcmp( const void * c1, const void * c2, size_t n )
    675 {
    676     dprintf(("CRTDLL: memcmp\n"));
    677     return memcmp( c1, c2, n );
    678 }
    679 
    680 /*********************************************************************
    681  *                  memcpy   (CRTDLL.430)
    682  */
    683 void * CDECL CRTDLL_memcpy( void *s1, const void *s2, size_t n )
    684 {
    685     dprintf(("CRTDLL: memcpy\n"));
    686     return memcpy( s1, s2, n );
    687 }
    688 
    689 /*********************************************************************
    690  *                  memset   (CRTDLL.432)
    691  */
    692 void * CDECL CRTDLL_memset( void *s, int i, size_t n )
    693 {
    694     dprintf(("CRTDLL: memset\n"));
    695     return memset( s, i, n );
     1100 *                  mktime   (CRTDLL.433)
     1101 */
     1102time_t CDECL CRTDLL_mktime( struct tm *timeptr )
     1103{
     1104    dprintf(("CRTDLL: mktime\n"));
     1105    return mktime( timeptr );
     1106}
     1107
     1108/*********************************************************************
     1109 *                  modf   (CRTDLL.434)
     1110 */
     1111double CDECL CRTDLL_modf( double value, double *iptr )
     1112{
     1113    dprintf(("CRTDLL: modf\n"));
     1114    return modf( value, iptr );
     1115}
     1116
     1117/*********************************************************************
     1118 *                  perror   (CRTDLL.435)
     1119 */
     1120void CDECL CRTDLL_perror( const char *s )
     1121{
     1122    dprintf(("CRTDLL: perror\n"));
     1123    perror( s );
     1124}
     1125
     1126/*********************************************************************
     1127 *                  printf   (CRTDLL.437)
     1128 */
     1129int CDECL CRTDLL_printf( const char *format, ... )
     1130{
     1131    dprintf(("CRTDLL: printf\n"));
     1132    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1133    return FALSE;
     1134}
     1135
     1136/*********************************************************************
     1137 *                  putc      (CRTDLL.438)
     1138 */
     1139int CDECL CRTDLL_putc( int c, FILE *fp )
     1140{
     1141    dprintf(("CRTDLL: putc\n"));
     1142    return putc( c, fp );
     1143}
     1144
     1145/*********************************************************************
     1146 *                  putchar      (CRTDLL.439)
     1147 */
     1148int CDECL CRTDLL_putchar( int c )
     1149{
     1150    dprintf(("CRTDLL: putchar\n"));
     1151    return putchar( c );
     1152}
     1153
     1154/*********************************************************************
     1155 *                  puts         (CRTDLL.440)
     1156 */
     1157int CDECL CRTDLL_puts( const char *s )
     1158{
     1159    dprintf(("CRTDLL: puts\n"));
     1160    return puts( s );
     1161}
     1162
     1163/*********************************************************************
     1164 *                  raise        (CRTDLL.442)
     1165 */
     1166int CDECL CRTDLL_raise( int sig )
     1167{
     1168    dprintf(("CRTDLL: raise\n"));
     1169    return raise( sig );
     1170}
     1171
     1172/*********************************************************************
     1173 *                  rand   (CRTDLL.443)
     1174 */
     1175int CDECL CRTDLL_rand( void )
     1176{
     1177    dprintf(("CRTDLL: rand\n"));
     1178    return (rand());
     1179}
     1180
     1181/*********************************************************************
     1182 *                  realloc   (CRTDLL.444)
     1183 */
     1184void * CDECL CRTDLL_realloc( void *ptr, size_t size )
     1185{
     1186    dprintf(("CRTDLL: realloc\n"));
     1187    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1188    return FALSE;
    6961189}
    6971190
    … …  
    7081201
    7091202/*********************************************************************
     1203 *                  rename      (CRTDLL.446)
     1204 */
     1205int CDECL CRTDLL_rename (const char *old, const char *new2)
     1206{
     1207  dprintf(("CRTDLL: rename\n"));
     1208  return (rename(old, new2));
     1209}
     1210
     1211/*********************************************************************
     1212 *                  rewind      (CRTDLL.447)
     1213 */
     1214void CDECL CRTDLL_rewind( FILE *fp )
     1215{
     1216  dprintf(("CRTDLL: rewind\n"));
     1217  rewind(fp);
     1218}
     1219
     1220/*********************************************************************
     1221 *                  scanf       (CRTDLL.448)
     1222 */
     1223int CDECL CRTDLL_scanf( const char *format, ... )
     1224{
     1225  dprintf(("CRTDLL: scanf\n"));
     1226  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1227  return FALSE;
     1228}
     1229       
     1230/*********************************************************************
     1231 *                  setbuf      (CRTDLL.449)
     1232 */
     1233void CDECL CRTDLL_setbuf( FILE *fp, char *buf )
     1234{
     1235  dprintf(("CRTDLL: setbuf\n"));
     1236  setbuf(fp, buf);
     1237}
     1238
     1239/*********************************************************************
     1240 *                  setlocale      (CRTDLL.450)
     1241 */
     1242char * CDECL CRTDLL_setlocale(int category,const char *locale)
     1243{
     1244  dprintf(("CRTDLL: setlocale\n"));
     1245  return (setlocale(category, locale));
     1246}
     1247
     1248/*********************************************************************
     1249 *                  setvbuf      (CRTDLL.451)
     1250 */
     1251int CDECL CRTDLL_setvbuf( FILE *fp, char *buf, int mode, size_t size )
     1252{
     1253  dprintf(("CRTDLL: setvbuf\n"));
     1254  return (setvbuf(fp, buf, mode, size));
     1255}
     1256
     1257/*********************************************************************
     1258 *                  signal       (CRTDLL.452)
     1259 */
     1260void CDECL CRTDLL_signal( int sig, void (*func)(int))
     1261{
     1262    dprintf(("CRTDLL: signal\n"));
     1263    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1264}
     1265
     1266/*********************************************************************
     1267 *                  sinh         (CRTDLL.454)
     1268 */
     1269double CDECL CRTDLL_sinh( double x )
     1270{
     1271  dprintf(("CRTDLL: sinh\n"));
     1272  return (sinh(x));
     1273}
     1274
     1275/*********************************************************************
     1276 *                  srand        (CRTDLL.457)
     1277 */
     1278void CDECL CRTDLL_srand( unsigned int seed )
     1279{
     1280  dprintf(("CRTDLL: srand\n"));
     1281  srand(seed);
     1282}
     1283
     1284/*********************************************************************
     1285 *                  strcoll        (CRTDLL.462)
     1286 */
     1287int CDECL CRTDLL_strcoll( const char *s1, const char *s2 )
     1288{
     1289  dprintf(("CRTDLL: strcoll\n"));
     1290  return strcoll(s1, s2);
     1291}
     1292
     1293/*********************************************************************
     1294 *                  strerror        (CRTDLL.465)
     1295 */
     1296char * CDECL CRTDLL_strerror( int errnum )
     1297{
     1298  dprintf(("CRTDLL: strerror\n"));
     1299  return strerror(errnum);
     1300}
     1301
     1302/*********************************************************************
     1303 *                  strftime        (CRTDLL.466)
     1304 */
     1305size_t CDECL CRTDLL_strftime( char *s, size_t maxsiz, const char *fmt, const struct tm *tp )
     1306{
     1307  dprintf(("CRTDLL: strftime\n"));
     1308  return strftime(s, maxsiz, fmt, tp);
     1309}
     1310 
     1311
     1312/*********************************************************************
     1313 *                  strtod        (CRTDLL.475)
     1314 */
     1315double CDECL CRTDLL_strtod( const char *nptr, char **endptr )
     1316{
     1317  dprintf(("CRTDLL: strtod\n"));
     1318  return strtod(nptr, endptr);
     1319}
     1320
     1321/*********************************************************************
     1322 *                  strtok        (CRTDLL.476)
     1323 */
     1324char * CDECL CRTDLL_strtok( char *s1, const char *s2 )
     1325{
     1326  dprintf(("CRTDLL: strtok\n"));
     1327  return strtok(s1, s2);
     1328}
     1329
     1330/*********************************************************************
     1331 *                  strtol        (CRTDLL.477)
     1332 */
     1333long int CDECL CRTDLL_strtol( const char *nptr, char **endptr, int base )
     1334{
     1335  dprintf(("CRTDLL: strtol\n"));
     1336  return strtol(nptr, endptr, base);
     1337}
     1338
     1339/*********************************************************************
     1340 *                  strtoul        (CRTDLL.478)
     1341 */
     1342unsigned long CDECL CRTDLL_strtoul( const char *nptr, char **endptr, int base )
     1343{
     1344  dprintf(("CRTDLL: strtoul\n"));
     1345  return strtoul(nptr, endptr, base);
     1346}
     1347
     1348/*********************************************************************
     1349 *                  strxfrm        (CRTDLL.479)
     1350 */
     1351size_t CDECL CRTDLL_strxfrm( char *s1, const char *s2, size_t n )
     1352{
     1353  dprintf(("CRTDLL: strxfrm\n"));
     1354  return strxfrm(s1, s2, n);
     1355}
     1356
     1357/*********************************************************************
     1358 *                  swscanf           (CRTDLL.481)
     1359 */
     1360int CDECL CRTDLL_swscanf( const wchar_t *s1, const wchar_t *s2, ... )
     1361{
     1362  dprintf(("CRTDLL: swscanf\n"));
     1363  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1364  return FALSE;
     1365}
     1366
     1367/*********************************************************************
     1368 *                  system         (CRTDLL.482)
     1369 */
     1370int CDECL CRTDLL_system( const char *string )
     1371{
     1372  dprintf(("CRTDLL: system\n"));
     1373  return system(string);
     1374}
     1375
     1376/*********************************************************************
     1377 *                  tanh           (CRTDLL.485)
     1378 */
     1379double CDECL CRTDLL_tanh( double x )
     1380{
     1381  dprintf(("CRTDLL: tanh\n"));
     1382  return tanh(x);
     1383}
     1384
     1385/*********************************************************************
     1386 *                  time           (CRTDLL.485)
     1387 */
     1388time_t CDECL CRTDLL_time( time_t *timer )
     1389{
     1390  dprintf(("CRTDLL: time\n"));
     1391
     1392  return time(timer);
     1393}
     1394
     1395/*********************************************************************
     1396 *                  tmpnam           (CRTDLL.486)
     1397 */
     1398FILE * CDECL CRTDLL_tmpfile( void )
     1399{
     1400  dprintf(("CRTDLL: tmpfile\n"));
     1401  return (tmpfile());
     1402}
     1403       
     1404/*********************************************************************
     1405 *                  tmpnam           (CRTDLL.487)
     1406 */
     1407char * CDECL CRTDLL_tmpnam( char *s )
     1408{
     1409  dprintf(("CRTDLL: tmpnam\n"));
     1410
     1411  return (tmpnam(s));
     1412}
     1413
     1414/*********************************************************************
     1415 *                  ungetc           (CRTDLL.492)
     1416 */
     1417INT CDECL CRTDLL_ungetc(int c)
     1418{
     1419  dprintf(("CRTDLL: ungetc\n"));
     1420  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1421  return FALSE;
     1422}
     1423
     1424/*********************************************************************
     1425 *                  ungetwc           (CRTDLL.493)
     1426 */
     1427wint_t CDECL CRTDLL_ungetwc( wint_t wc, FILE *strm )
     1428{
     1429  dprintf(("CRTDLL: ungetwc\n"));
     1430
     1431  return (ungetwc(wc, strm));
     1432}
     1433
     1434/*********************************************************************
    7101435 *                  vfprintf       (CRTDLL.494)
    7111436 */
    … …  
    7401465
    7411466/*********************************************************************
    742  *                  vsprintf       (CRTDLL.497)
    743  */
    744 int CDECL CRTDLL_vsprintf( char *s, const char *format, va_list arg )
    745 {
    746   dprintf(("CRTDLL: vsprintf\n"));
    747 
    748   return (vsprintf(s, format, arg));
    749 }
    750 
    751 /*********************************************************************
    7521467 *                  vswprintf       (CRTDLL.498)
    7531468 */
    … …  
    8011516
    8021517/*********************************************************************
    803  *                  wcstok   (CRTDLL.516)
    804  */
    805 wchar_t *CRTDLL_wcstok( wchar_t *s1, const wchar_t *s2, wchar_t **ptr )
    806 {
    807   dprintf(("CRTDLL: wcstod\n"));
    808   return (wcstok(s1, s2, ptr));
    809 }
    810 /*********************************************************************
    811  *                  wcstol   (CRTDLL.517)
    812  */
    813 long int CDECL CRTDLL_wcstol( const wchar_t *s1, wchar_t **s2, int i )
    814 {
    815   dprintf(("CRTDLL: wcstol\n"));
    816 
    817   return (wcstol(s1, s2, i));
    818 }
    819 
    820 /*********************************************************************
    821  *                  wcstombs   (CRTDLL.518)
    822  */
    823 size_t CDECL CRTDLL_wcstombs( char *s, const wchar_t *pwcs, size_t n )
    824 {
    825   dprintf(("CRTDLL: wcstombs\n"));
    826 
    827   return (wcstombs(s, pwcs, n));
    828 }
    829 
    830 /*********************************************************************
    831  *                  wcstoul   (CRTDLL.519)
    832  */
    833 unsigned long int CDECL CRTDLL_wcstoul( const wchar_t *s1, wchar_t **s2, int i )
    834 {
    835   dprintf(("CRTDLL: wcstoul\n"));
    836 
    837   return (wcstoul(s1, s2, i));
    838 }
    839 
    840 /*********************************************************************
    8411518 *                  wcsxfrm   (CRTDLL.520)
    8421519 */
    … …  
    8591536
    8601537/*********************************************************************
    861  *                  fwprintf   (CRTDLL.522)
    862  */
    863 int CDECL CRTDLL_fwprintf( const wchar_t *s, ... )
    864 {
    865   dprintf(("CRTDLL: fwprintf\n"));
     1538 *                  wprintf   (CRTDLL.522)
     1539 */
     1540int CDECL CRTDLL_wprintf( const wchar_t *s, ... )
     1541{
     1542  dprintf(("CRTDLL: wprintf\n"));
    8661543  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    8671544  return FALSE;
Note: See TracChangeset for help on using the changeset viewer.