Ignore:
Timestamp:
Oct 4, 1999, 11:56:04 AM (26 years ago)
Author:
sandervl
Message:

Lots of changes by several people (see changelog for 4 October

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/msvcrt/msvcrt.cpp

    r1103 r1118  
    1 /* $Id: msvcrt.cpp,v 1.2 1999-10-01 16:02:32 sandervl Exp $ */
     1/* $Id: msvcrt.cpp,v 1.3 1999-10-04 09:55:58 sandervl Exp $ */
    22
    33/*
    … …  
    6868
    6969/*********************************************************************
     70 *                  _get_sbh_threshold    (MSVCRT.247)
     71 */
     72size_t CDECL MSVCRT__get_sbh_threshold( void )
     73{
     74  dprintf(("MSVCRT: _get_sbh_threshold not implemented.\n"));
     75  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     76  return FALSE;
     77}
     78
     79
     80/*********************************************************************
     81 *                  _getmbcp    (MSVCRT.257)
     82 */
     83int CDECL MSVCRT__getmbcp( void )
     84{
     85  dprintf(("MSVCRT: _getmbcp not implemented.\n"));
     86  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     87  return FALSE;
     88}
     89
     90
     91/*********************************************************************
    7092 *                  _getws    (MSVCRT.261)
    7193 */
    … …  
    79101
    80102/*********************************************************************
     103 *                  _inp    (MSVCRT.273)
     104 */
     105int CDECL MSVCRT__inp( unsigned short port )
     106{
     107  dprintf(("MSVCRT: _inp not implemented.\n"));
     108  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     109  return FALSE;
     110}
     111
     112
     113/*********************************************************************
     114 *                  _inpw    (MSVCRT.274)
     115 */
     116unsigned short CDECL MSVCRT__inpw( unsigned short port )
     117{
     118  dprintf(("MSVCRT: _inpw not implemented.\n"));
     119  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     120  return FALSE;
     121}
     122
     123
     124/*********************************************************************
     125 *                  _inpd    (MSVCRT.275)
     126 */
     127unsigned long CDECL MSVCRT__inpd( unsigned short port )
     128{
     129  dprintf(("MSVCRT: _inpd not implemented.\n"));
     130  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     131  return FALSE;
     132}
     133
     134
     135/*********************************************************************
    81136 *                  _ismbbkprint    (MSVCRT.284)
    82137 */
    … …  
    123178
    124179/*********************************************************************
     180 *                  _itow    (MSVCRT.310)
     181 */
     182wchar_t * CDECL MSVCRT__itow( int value, wchar_t *string, int radix )
     183{
     184  dprintf(("MSVCRT: _itow not implemented.\n"));
     185  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     186  return FALSE;
     187}
     188
     189
     190/*********************************************************************
     191 *                  _ltow    (MSVCRT.328)
     192 */
     193wchar_t * CDECL MSVCRT__ltow( long value, wchar_t *string, int radix )
     194{
     195  dprintf(("MSVCRT: _ltow not implemented.\n"));
     196  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     197  return FALSE;
     198}
     199
     200
     201/*********************************************************************
     202 *                  _outp    (MSVCRT.395)
     203 */
     204int CDECL MSVCRT__outp( unsigned short port, int databyte )
     205{
     206  dprintf(("MSVCRT: _outp not implemented.\n"));
     207  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     208  return FALSE;
     209}
     210
     211
     212/*********************************************************************
     213 *                  _outpw    (MSVCRT.396)
     214 */
     215unsigned short CDECL MSVCRT__outpw( unsigned short port, unsigned short dataword )
     216{
     217  dprintf(("MSVCRT: _outpw not implemented.\n"));
     218  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     219  return FALSE;
     220}
     221
     222
     223/*********************************************************************
     224 *                  _outpd    (MSVCRT.397)
     225 */
     226unsigned long CDECL MSVCRT__outpd( unsigned short port, unsigned long dataword )
     227{
     228  dprintf(("MSVCRT: _outpd not implemented.\n"));
     229  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     230  return FALSE;
     231}
     232
     233
     234/*********************************************************************
    125235 *                  _putws    (MSVCRT.407)
    126236 */
    … …  
    134244
    135245/*********************************************************************
     246 *                  _set_error_mode    (MSVCRT.421)
     247 */
     248int CDECL MSVCRT__set_error_mode( int modeval )
     249{
     250  dprintf(("MSVCRT: _set_error_mode not implemented.\n"));
     251  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     252  return FALSE;
     253}
     254
     255
     256/*********************************************************************
     257 *                  _set_sbh_threshold    (MSVCRT.422)
     258 */
     259int CDECL MSVCRT__set_sbh_threshold( size_t size )
     260{
     261  dprintf(("MSVCRT: _set_sbh_threshold not implemented.\n"));
     262  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     263  return FALSE;
     264}
     265
     266
     267/*********************************************************************
    136268 *                  _strncoll    (MSVCRT.453)
    137269 */
    … …  
    150282{
    151283  dprintf(("MSVCRT: _strnicoll not implemented.\n"));
     284  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     285  return FALSE;
     286}
     287
     288
     289/*********************************************************************
     290 *                  _ultow    (MSVCRT.475)
     291 */
     292wchar_t * CDECL MSVCRT__ultow( unsigned long value, wchar_t *string, int radix )
     293{
     294  dprintf(("MSVCRT: _ultow not implemented.\n"));
     295  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     296  return FALSE;
     297}
     298
     299
     300/*********************************************************************
     301 *                  _umask    (MSVCRT.476)
     302 */
     303int CDECL MSVCRT__umask( int pmode )
     304{
     305  dprintf(("MSVCRT: _umask not implemented.\n"));
     306  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     307  return FALSE;
     308}
     309
     310
     311/*********************************************************************
     312 *                  _waccess    (MSVCRT.484)
     313 */
     314int CDECL MSVCRT__waccess( const wchar_t *path, int mode )
     315{
     316  dprintf(("MSVCRT: _waccess not implemented.\n"));
     317  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     318  return FALSE;
     319}
     320
     321
     322/*********************************************************************
     323 *                  _wasctime    (MSVCRT.485)
     324 */
     325wchar_t * CDECL MSVCRT__wasctime( const struct tm *timeptr )
     326{
     327  dprintf(("MSVCRT: _wasctime not implemented.\n"));
     328  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     329  return FALSE;
     330}
     331
     332
     333/*********************************************************************
     334 *                  _wchdir    (MSVCRT.486)
     335 */
     336int CDECL MSVCRT__wchdir( const wchar_t *dirname )
     337{
     338  dprintf(("MSVCRT: _wchdir not implemented.\n"));
     339  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     340  return FALSE;
     341}
     342
     343
     344/*********************************************************************
     345 *                  _wchmod    (MSVCRT.487)
     346 */
     347int CDECL MSVCRT__wchmod( const wchar_t *filename, int pmode )
     348{
     349  dprintf(("MSVCRT: _wchmod not implemented.\n"));
     350  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     351  return FALSE;
     352}
     353
     354
     355/*********************************************************************
     356 *                  _wcreat    (MSVCRT.489)
     357 */
     358int CDECL MSVCRT__wcreat( const wchar_t *filename, int pmode )
     359{
     360  dprintf(("MSVCRT: _wcreat not implemented.\n"));
     361  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     362  return FALSE;
     363}
     364
     365
     366/*********************************************************************
     367 *                  _wcsncoll    (MSVCRT.494)
     368 */
     369int CDECL MSVCRT__wcsncoll( const wchar_t *string1, const wchar_t *string2, size_t count )
     370{
     371  dprintf(("MSVCRT: _wcsncoll not implemented.\n"));
     372  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     373  return FALSE;
     374}
     375
     376
     377/*********************************************************************
     378 *                  _wcsnicoll    (MSVCRT.496)
     379 */
     380int CDECL MSVCRT__wcsnicoll( const wchar_t *string1, const wchar_t *string2 , size_t count )
     381{
     382  dprintf(("MSVCRT: _wcsnicoll not implemented.\n"));
     383  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     384  return FALSE;
     385}
     386
     387
     388/*********************************************************************
     389 *                  _wctime       (MSVCRT.501)
     390 */
     391wchar_t * CDECL MSVCRT__wctime( const time_t *timer )
     392{
     393  dprintf(("MSVCRT: _wctime not implemented.\n"));
     394  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     395  return FALSE;
     396}
     397
     398
     399/*********************************************************************
     400 *                  _wexecl       (MSVCRT.503)
     401 */
     402int CDECL MSVCRT__wexecl( const wchar_t *path, const wchar_t *arg0, ... )
     403{
     404  dprintf(("MSVCRT: _wexecl not implemented.\n"));
     405  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     406  return FALSE;
     407}
     408
     409
     410/*********************************************************************
     411 *                  _wexecle       (MSVCRT.504)
     412 */
     413int CDECL MSVCRT__wexecle( const wchar_t *path, const wchar_t *arg0, ... )
     414{
     415  dprintf(("MSVCRT: _wexecle not implemented.\n"));
     416  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     417  return FALSE;
     418}
     419
     420
     421/*********************************************************************
     422 *                  _wexeclp       (MSVCRT.505)
     423 */
     424int CDECL MSVCRT__wexeclp( const wchar_t *file, const wchar_t *arg0, ... )
     425{
     426  dprintf(("MSVCRT: _wexeclp not implemented.\n"));
     427  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     428  return FALSE;
     429}
     430
     431
     432/*********************************************************************
     433 *                  _wexeclpe      (MSVCRT.506)
     434 */
     435int CDECL MSVCRT__wexeclpe( const wchar_t *file, const wchar_t *arg0, ... )
     436{
     437  dprintf(("MSVCRT: _wexeclpe not implemented.\n"));
     438  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     439  return FALSE;
     440}
     441
     442
     443/*********************************************************************
     444 *                  _wexecv      (MSVCRT.507)
     445 */
     446int CDECL MSVCRT__wexecv( const wchar_t *path, const wchar_t *const argv[] )
     447{
     448  dprintf(("MSVCRT: _wexecv not implemented.\n"));
     449  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     450  return FALSE;
     451}
     452
     453
     454/*********************************************************************
     455 *                  _wexecve     (MSVCRT.508)
     456 */
     457int CDECL MSVCRT__wexecve( const wchar_t *path, const wchar_t *const argv[],
     458                                  const wchar_t *const envp[] )
     459{
     460  dprintf(("MSVCRT: _wexecve not implemented.\n"));
     461  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     462  return FALSE;
     463}
     464
     465
     466/*********************************************************************
     467 *                  _wexecvp     (MSVCRT.509)
     468 */
     469int CDECL MSVCRT__wexecvp( const wchar_t *file, const wchar_t *const argv[] )
     470{
     471  dprintf(("MSVCRT: _wexecvp not implemented.\n"));
     472  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     473  return FALSE;
     474}
     475
     476
     477/*********************************************************************
     478 *                  _wexecvpe     (MSVCRT.510)
     479 */
     480int CDECL MSVCRT__wexecvpe( const wchar_t *file, const wchar_t *const argv[],
     481                                   const wchar_t *const envp[] )
     482{
     483  dprintf(("MSVCRT: _wexecvpe not implemented.\n"));
     484  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     485  return FALSE;
     486}
     487
     488
     489/*********************************************************************
     490 *                  _wfdopen     (MSVCRT.511)
     491 */
     492FILE * CDECL MSVCRT__wfdopen( int, const wchar_t *s )
     493{
     494  dprintf(("MSVCRT: _wfdopen not implemented.\n"));
     495  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     496  return FALSE;
     497}
     498
     499
     500/*********************************************************************
     501 *                  _wfindfirst     (MSVCRT.512)
     502 */
     503long CDECL MSVCRT__wfindfirst( const wchar_t *filespec, struct _wfinddata_t *fileinfo )
     504{
     505  dprintf(("MSVCRT: _wfindfirst not implemented.\n"));
     506  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     507  return FALSE;
     508}
     509
     510
     511/*********************************************************************
     512 *                  _wfindnext     (MSVCRT.514)
     513 */
     514int CDECL MSVCRT__wfindnext( long handle, struct _wfinddata_t *fileinfo )
     515{
     516  dprintf(("MSVCRT: _wfindnext not implemented.\n"));
     517  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     518  return FALSE;
     519}
     520
     521
     522/*********************************************************************
     523 *                  _wfopen        (MSVCRT.516)
     524 */
     525FILE * CDECL MSVCRT__wfopen( const wchar_t *s1, const wchar_t *s2 )
     526{
     527  dprintf(("MSVCRT: _wfopen not implemented.\n"));
     528  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     529  return FALSE;
     530}
     531
     532
     533/*********************************************************************
     534 *                  _wfreopen        (MSVCRT.517)
     535 */
     536FILE * CDECL MSVCRT__wfreopen( const wchar_t *s1, const wchar_t *s2, FILE * f)
     537{
     538  dprintf(("MSVCRT: _wfreopen not implemented.\n"));
     539  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     540  return FALSE;
     541}
     542
     543
     544/*********************************************************************
     545 *                  _wfsopen        (MSVCRT.518)
     546 */
     547FILE * CDECL MSVCRT__wfsopen( const wchar_t *filename, const wchar_t *mode,  int shflag )
     548{
     549  dprintf(("MSVCRT: _wfsopen not implemented.\n"));
     550  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     551  return FALSE;
     552}
     553
     554
     555/*********************************************************************
     556 *                  _wfullpath        (MSVCRT.519)
     557 */
     558wchar_t * CDECL MSVCRT__wfullpath( wchar_t *s1, const wchar_t *s2, size_t n )
     559{
     560  dprintf(("MSVCRT: _wfullpath not implemented.\n"));
     561  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     562  return FALSE;
     563}
     564
     565
     566/*********************************************************************
     567 *                  _wgetcwd          (MSVCRT.520)
     568 */
     569wchar_t * CDECL MSVCRT__wgetcwd( wchar_t *buf, size_t size )
     570{
     571  dprintf(("MSVCRT: _wgetcwd not implemented.\n"));
     572  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     573  return FALSE;
     574}
     575
     576
     577/*********************************************************************
     578 *                  _wgetdcwd          (MSVCRT.521)
     579 */
     580wchar_t * CDECL MSVCRT__wgetdcwd( int drive, wchar_t *buffer, size_t maxlen )
     581{
     582  dprintf(("MSVCRT: _wgetdcwd not implemented.\n"));
     583  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     584  return FALSE;
     585}
     586
     587
     588/*********************************************************************
     589 *                  _wgetenv          (MSVCRT.522)
     590 */
     591wchar_t * CDECL MSVCRT__wgetenv( const wchar_t *name )
     592{
     593  dprintf(("MSVCRT: _wgetenv not implemented.\n"));
     594  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     595  return FALSE;
     596}
     597
     598
     599/*********************************************************************
     600 *                  _wmakepath          (MSVCRT.526)
     601 */
     602void CDECL MSVCRT__wmakepath( wchar_t *path, const wchar_t *drive,
     603            const wchar_t *dir, const wchar_t *fname, const wchar_t *ext )
     604{
     605  dprintf(("MSVCRT: _wmakepath not implemented.\n"));
     606  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     607}
     608
     609
     610/*********************************************************************
     611 *                  _wmkdir           (MSVCRT.527)
     612 */
     613int CDECL MSVCRT__wmkdir( const wchar_t *path )
     614{
     615  dprintf(("MSVCRT: _wmkdir not implemented.\n"));
     616  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     617  return FALSE;
     618}
     619
     620
     621/*********************************************************************
     622 *                  _wmktemp           (MSVCRT.528)
     623 */
     624wchar_t * CDECL MSVCRT__wmktemp( wchar_t*  )
     625{
     626  dprintf(("MSVCRT: _wmktemp not implemented.\n"));
     627  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     628  return FALSE;
     629}
     630
     631
     632/*********************************************************************
     633 *                  _wopen           (MSVCRT.529)
     634 */
     635int CDECL MSVCRT__wopen( const wchar_t *s, int n, ... )
     636{
     637  dprintf(("MSVCRT: _wopen not implemented.\n"));
     638  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     639  return FALSE;
     640}
     641
     642
     643/*********************************************************************
     644 *                  _wperror          (MSVCRT.530)
     645 */
     646void CDECL MSVCRT__wperror( const wchar_t *s )
     647{
     648  dprintf(("MSVCRT: _wperror not implemented.\n"));
     649  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     650}
     651
     652
     653/*********************************************************************
     654 *                  _wpopen           (MSVCRT.532)
     655 */
     656FILE * CDECL MSVCRT__wpopen( const wchar_t *command, const wchar_t *mode )
     657{
     658  dprintf(("MSVCRT: _wpopen not implemented.\n"));
     659  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     660  return FALSE;
     661}
     662
     663
     664/*********************************************************************
     665 *                  _wputenv          (MSVCRT.533)
     666 */
     667int CDECL MSVCRT__wputenv( const wchar_t *env_string )
     668{
     669  dprintf(("MSVCRT: _wputenv not implemented.\n"));
     670  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     671  return FALSE;
     672}
     673
     674
     675/*********************************************************************
     676 *                  _wremove          (MSVCRT.534)
     677 */
     678int CDECL MSVCRT__wremove( const wchar_t *s )
     679{
     680  dprintf(("MSVCRT: _wremove not implemented.\n"));
     681  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     682  return FALSE;
     683}
     684
     685
     686/*********************************************************************
     687 *                  _wrename          (MSVCRT.535)
     688 */
     689int CDECL MSVCRT__wrename( const wchar_t *s1, const wchar_t *s2 )
     690{
     691  dprintf(("MSVCRT: _wrename not implemented.\n"));
     692  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     693  return FALSE;
     694}
     695
     696
     697/*********************************************************************
     698 *                  _wrmdir          (MSVCRT.537)
     699 */
     700int CDECL MSVCRT__wrmdir( const wchar_t *path )
     701{
     702  dprintf(("MSVCRT: _wrmdir not implemented.\n"));
     703  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     704  return FALSE;
     705}
     706
     707
     708/*********************************************************************
     709 *                  _wsearchenv          (MSVCRT.538)
     710 */
     711void CDECL MSVCRT__wsearchenv( const wchar_t *name, const wchar_t *env_var, wchar_t *buf )
     712{
     713  dprintf(("MSVCRT: _wsearchenv not implemented.\n"));
     714  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     715}
     716
     717
     718/*********************************************************************
     719 *                  _wsetlocale          (MSVCRT.539)
     720 */
     721wchar_t * CDECL MSVCRT__wsetlocale(int category,const wchar_t *locale)
     722{
     723  dprintf(("MSVCRT: _wsetlocale not implemented.\n"));
     724  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     725  return FALSE;
     726}
     727
     728
     729/*********************************************************************
     730 *                  _wsopen          (MSVCRT.540)
     731 */
     732int CDECL MSVCRT__wsopen( const wchar_t *s, int n1, int n2, ... )
     733{
     734  dprintf(("MSVCRT: _wsopen not implemented.\n"));
     735  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     736  return FALSE;
     737}
     738
     739
     740/*********************************************************************
     741 *                  _wspawnl         (MSVCRT.541)
     742 */
     743int CDECL MSVCRT__wspawnl( int mode, const wchar_t *path, const wchar_t *arg0, ... )
     744{
     745  dprintf(("MSVCRT: _wspawnl not implemented.\n"));
     746  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     747  return FALSE;
     748}
     749
     750
     751/*********************************************************************
     752 *                  _wspawnle          (MSVCRT.542)
     753 */
     754int CDECL MSVCRT__wspawnle( int mode, const wchar_t *path, const wchar_t *arg0, ... )
     755{
     756  dprintf(("MSVCRT: _wspawnle not implemented.\n"));
     757  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     758  return FALSE;
     759}
     760
     761
     762/*********************************************************************
     763 *                  _wspawnlp          (MSVCRT.543)
     764 */
     765int CDECL MSVCRT__wspawnlp( int mode, const wchar_t *path, const wchar_t *arg0, ... )
     766{
     767  dprintf(("MSVCRT: _wspawnlp not implemented.\n"));
     768  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     769  return FALSE;
     770}
     771
     772
     773/*********************************************************************
     774 *                  _wspawnlpe          (MSVCRT.544)
     775 */
     776int CDECL MSVCRT__wspawnlpe( int mode, const wchar_t *path, const wchar_t *arg0, ... )
     777{
     778  dprintf(("MSVCRT: _wspawnlpe not implemented.\n"));
     779  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     780  return FALSE;
     781}
     782
     783
     784/*********************************************************************
     785 *                  _wspawnv          (MSVCRT.545)
     786 */
     787int CDECL MSVCRT__wspawnv( int mode, const wchar_t *path, const wchar_t * const *argv )
     788{
     789  dprintf(("MSVCRT: _wspawnv not implemented.\n"));
     790  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     791  return FALSE;
     792}
     793
     794
     795/*********************************************************************
     796 *                  _wspawnve          (MSVCRT.546)
     797 */
     798int CDECL MSVCRT__wspawnve( int mode, const wchar_t *path,
     799           const wchar_t * const *argv, const wchar_t * const *envp )
     800{
     801  dprintf(("MSVCRT: _wspawnve not implemented.\n"));
     802  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     803  return FALSE;
     804}
     805
     806
     807/*********************************************************************
     808 *                  _wspawnvp          (MSVCRT.547)
     809 */
     810int CDECL MSVCRT__wspawnvp( int mode, const wchar_t *path, const wchar_t * const *argv )
     811{
     812  dprintf(("MSVCRT: _wspawnvp not implemented.\n"));
     813  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     814  return FALSE;
     815}
     816
     817
     818/*********************************************************************
     819 *                  _wspawnvpe          (MSVCRT.548)
     820 */
     821int CDECL MSVCRT__wspawnvpe( int mode, const wchar_t *path,
     822           const wchar_t * const *argv, const wchar_t * const *envp )
     823{
     824  dprintf(("MSVCRT: _wspawnvpe not implemented.\n"));
     825  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     826  return FALSE;
     827}
     828
     829
     830/*********************************************************************
     831 *                  _wsplitpath         (MSVCRT.549)
     832 */
     833void CDECL MSVCRT__wsplitpath( const wchar_t *path, wchar_t *drive,
     834                 wchar_t *dir, wchar_t *fname, wchar_t *ext )
     835{
     836  dprintf(("MSVCRT: _wsplitpath not implemented.\n"));
     837  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     838}
     839
     840
     841/*********************************************************************
     842 *                  _wstat          (MSVCRT.550)
     843 */
     844int CDECL MSVCRT__wstat( const wchar_t *s, struct _wstat *w )
     845{
     846  dprintf(("MSVCRT: _wstat not implemented.\n"));
     847  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     848  return FALSE;
     849}
     850
     851
     852/*********************************************************************
     853 *                  _wstrdate          (MSVCRT.552)
     854 */
     855wchar_t * CDECL MSVCRT__wstrdate( wchar_t *buf )
     856{
     857  dprintf(("MSVCRT: _wstrdate not implemented.\n"));
     858  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     859  return FALSE;
     860}
     861
     862
     863/*********************************************************************
     864 *                  _wstrtime          (MSVCRT.553)
     865 */
     866wchar_t * CDECL MSVCRT__wstrtime( wchar_t *buf )
     867{
     868  dprintf(("MSVCRT: _wstrtime not implemented.\n"));
     869  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     870  return FALSE;
     871}
     872
     873
     874/*********************************************************************
     875 *                  _wsystem           (MSVCRT.554)
     876 */
     877int CDECL MSVCRT__wsystem( const wchar_t *cmd )
     878{
     879  dprintf(("MSVCRT: _wsystem not implemented.\n"));
     880  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     881  return FALSE;
     882}
     883
     884
     885/*********************************************************************
     886 *                  _wtempnam          (MSVCRT.555)
     887 */
     888wchar_t * CDECL MSVCRT__wtempnam( wchar_t *dir, wchar_t *prefix )
     889{
     890  dprintf(("MSVCRT: _wtempnam not implemented.\n"));
     891  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     892  return FALSE;
     893}
     894
     895
     896/*********************************************************************
     897 *                  _wtmpnam          (MSVCRT.555)
     898 */
     899wchar_t * CDECL MSVCRT__wtmpnam( wchar_t *tn )
     900{
     901  dprintf(("MSVCRT: _wtmpnam not implemented.\n"));
     902  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     903  return FALSE;
     904}
     905
     906
     907/*********************************************************************
     908 *                  _wunlink     (MSVCRT.560)
     909 */
     910int CDECL MSVCRT__wunlink(const wchar_t *path)
     911{
     912  dprintf(("MSVCRT: _wunlink not implemented.\n"));
     913  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     914  return FALSE;
     915}
     916
     917
     918/*********************************************************************
     919 *                  _wutime     (MSVCRT.561)
     920 */
     921int CDECL MSVCRT__wutime( const wchar_t *path, const struct utimbuf * times )
     922{
     923  dprintf(("MSVCRT: _wutime not implemented.\n"));
    152924  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    153925  return FALSE;
Note: See TracChangeset for help on using the changeset viewer.