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/crtdll/crtdll.cpp

    r1083 r1118  
    1 /* $Id: crtdll.cpp,v 1.6 1999-09-28 13:26:34 sandervl Exp $ */
     1/* $Id: crtdll.cpp,v 1.7 1999-10-04 09:55:54 sandervl Exp $ */
    22
    33/*
    … …  
    2929#include <wctype.h>
    3030#include <math.h>
    31 #include <locale.h>
     31#include <libc\locale.h>
    3232#include <signal.h>
    3333#include <io.h>
    … …  
    4040#include <drive.h>
    4141#include <fcntl.h>
     42#include <search.h>
    4243#include <sys\utime.h>
    4344#include <sys\stat.h>
    … …  
    100101
    101102/*********************************************************************
     103 *                  _CIacos    (CRTDLL.004)
     104 */
     105double CDECL CRTDLL__CIacos( double x )
     106{
     107  dprintf(("NTDLL: _CIacos\n"));
     108  dprintf(("should be register function\n"));
     109  return acos(x);
     110}
     111
     112
     113/*********************************************************************
     114 *                  _CIasin    (CRTDLL.005)
     115 */
     116double CDECL CRTDLL__CIasin( double x )
     117{
     118  dprintf(("NTDLL: _CIasin\n"));
     119  dprintf(("should be register function\n"));
     120  return asin(x);
     121}
     122
     123
     124/*********************************************************************
     125 *                  _CIatan    (CRTDLL.006)
     126 */
     127double CDECL CRTDLL__CIatan( double x )
     128{
     129  dprintf(("NTDLL: _CIatan\n"));
     130  dprintf(("should be register function\n"));
     131  return atan(x);
     132}
     133
     134
     135/*********************************************************************
     136 *                  _CIatan2    (CRTDLL.007)
     137 */
     138double CDECL CRTDLL__CIatan2( double x, double y )
     139{
     140  dprintf(("NTDLL: _CIatan2\n"));
     141  dprintf(("should be register function\n"));
     142  return atan2(x,y);
     143}
     144
     145
     146/*********************************************************************
     147 *                  _CIcos    (CRTDLL.008)
     148 */
     149double CDECL CRTDLL__CIcos( double x )
     150{
     151  dprintf(("NTDLL: _CIcos\n"));
     152  dprintf(("should be register function\n"));
     153  return cos(x);
     154}
     155
     156
     157/*********************************************************************
     158 *                  _CIcosh    (CRTDLL.009)
     159 */
     160double CDECL CRTDLL__CIcosh( double x )
     161{
     162  dprintf(("NTDLL: _CIcosh\n"));
     163  dprintf(("should be register function\n"));
     164  return cosh(x);
     165}
     166
     167
     168/*********************************************************************
     169 *                  _CIexp    (CRTDLL.010)
     170 */
     171double CDECL CRTDLL__CIexp( double x )
     172{
     173  dprintf(("NTDLL: _CIexp\n"));
     174  dprintf(("should be register function\n"));
     175  return exp(x);
     176}
     177
     178
     179/*********************************************************************
     180 *                  _CIfmod     (CRTDLL.011)
     181 */
     182double CDECL CRTDLL__CIfmod( double x, double y )
     183{
     184  dprintf(("NTDLL: _CIfmod\n"));
     185  dprintf(("should be register function\n"));
     186  return fmod(x,y);
     187}
     188
     189
     190/*********************************************************************
     191 *                  _CIlog    (CRTDLL.012)
     192 */
     193double CDECL CRTDLL__CIlog( double x )
     194{
     195  dprintf(("NTDLL: _CIlog\n"));
     196  dprintf(("should be register function\n"));
     197  return log(x);
     198}
     199
     200
     201/*********************************************************************
     202 *                  _CIlog10    (CRTDLL.013)
     203 */
     204double CDECL CRTDLL__CIlog10( double x )
     205{
     206  dprintf(("NTDLL: _CIlog10\n"));
     207  dprintf(("should be register function\n"));
     208  return log10(x);
     209}
     210
     211
     212/*********************************************************************
     213 *                  _CIsin     (CRTDLL.015)
     214 */
     215double CDECL CRTDLL__CIsin( double x )
     216{
     217  dprintf(("NTDLL: _CIsin\n"));
     218  dprintf(("should be register function\n"));
     219  return sin(x);
     220}
     221
     222
     223/*********************************************************************
     224 *                  _CIsinh    (CRTDLL.016)
     225 */
     226double CDECL CRTDLL__CIsinh( double x )
     227{
     228  dprintf(("NTDLL: _CIsinh\n"));
     229  dprintf(("should be register function\n"));
     230  return sinh(x);
     231}
     232
     233
     234/*********************************************************************
     235 *                  _CIsqrt    (CRTDLL.017)
     236 */
     237double CDECL CRTDLL__CIsqrt( double x )
     238{
     239  dprintf(("NTDLL: _CIsqrt\n"));
     240  dprintf(("should be register function\n"));
     241  return acos(x);
     242}
     243
     244
     245/*********************************************************************
     246 *                  _CItan    (CRTDLL.018)
     247 */
     248double CDECL CRTDLL__CItan( double x )
     249{
     250  dprintf(("NTDLL: _CItan\n"));
     251  dprintf(("should be register function\n"));
     252  return tan(x);
     253}
     254
     255
     256/*********************************************************************
     257 *                  _CItanh    (CRTDLL.019)
     258 */
     259double CDECL CRTDLL__CItanh( double x )
     260{
     261  dprintf(("NTDLL: _CItanh\n"));
     262  dprintf(("should be register function\n"));
     263  return tanh(x);
     264}
     265
     266
     267/*********************************************************************
    102268 *                  _XcptFilter    (CRTDLL.21)
    103269 *      FIXME - Could not find anything about it
    … …  
    109275  return FALSE;
    110276}
     277
    111278
    112279/*********************************************************************
    … …  
    139306
    140307        /* missing threading init */
     308
     309        i=0;xargv=NULL;xargc=0;afterlastspace=0;
    141310/*
    142         i=0;xargv=NULL;xargc=0;afterlastspace=0;
    143311        dprintf(("CRTDLL: GetMainArgs i loop\n"));
    144312        while (cmdline[i]) {
    … …  
    157325                                afterlastspace=i;
    158326        dprintf(("CRTDLL: GetMainArgs *3\n"));
     327
    159328                } else
    160329                        i++;
    161330
    162331        }
     332
    163333        xargv=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv,
    164334                                   sizeof(char*)*(++xargc));
    … …  
    168338        xargv[xargc-1] = HEAP_strdupA( GetProcessHeap(), 0,
    169339                                       cmdline+afterlastspace);
    170         dprintf(("CRTDLL: GetMainArgs *6\n"));
    171         dprintf(("CRTDLL: GetMainArgs *7\n"));
     340*/
    172341        CRTDLL_argc_dll = xargc;
    173         dprintf(("CRTDLL: GetMainArgs *8\n"));
    174342        *argc           = xargc;
    175         dprintf(("CRTDLL: GetMainArgs *9\n"));
    176343        CRTDLL_argv_dll = xargv;
    177         dprintf(("CRTDLL: GetMainArgs *11\n"));
    178344        *argv           = xargv;
    179 */
    180345        dprintf(("CRTDLL: GetMainArgs end\n"));
    181346        CRTDLL_environ_dll = *environ = GetEnvironmentStringsA();
    … …  
    194359
    195360/*********************************************************************
     361 *                  __doserrno            (CRTDLL.26)
     362 */
     363long * CDECL CRTDLL___doserrno()
     364{       
     365        dprintf(("__doserrno not implemented.\n"));
     366        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     367        return FALSE;
     368//      return _doserrno();
     369}
     370
     371
     372/*********************************************************************
    196373 *           CRTDLL___isascii   (CRTDLL.28)
    197374 */
    … …  
    315492
    316493/*********************************************************************
     494 *                  CRTDLL__beep                    (CRTDLL.45)
     495 */
     496void CDECL CRTDLL__beep(unsigned i1, unsigned i2)
     497{       
     498        dprintf(("_beep not implemented.\n"));
     499}
     500
     501
     502/*********************************************************************
    317503 *           CRTDLL__beginthread   (CRTDLL.46)
    318504 */
    … …  
    338524
    339525/*********************************************************************
     526 *           CRTDLL__cabs   (CRTDLL.48)
     527 */
     528double CDECL CRTDLL__cabs(struct complex * c)
     529{
     530  dprintf(("CRTDLL: _cabs not implemented.\n"));
     531  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     532  return FALSE;
     533//  return (_cabs(c));
     534}
     535
     536
     537/*********************************************************************
    340538 *                  _cexit          (CRTDLL.49)
    341539 *
    … …  
    345543        dprintf(("_cexit(%d)\n",ret));
    346544        ExitProcess(ret);
     545}
     546
     547
     548/*********************************************************************
     549 *           CRTDLL__cgets  (CRTDLL.50)
     550 */
     551char * CDECL CRTDLL__cgets( char *s )
     552{
     553  dprintf(("CRTDLL: _cgets\n"));
     554  return (_cgets(s));
    347555}
    348556
    … …  
    375583
    376584/*********************************************************************
     585 *           CRTDLL__chgsign     (CRTDLL.53)
     586 */
     587double CDECL CRTDLL__chgsign(double x)
     588{
     589  dprintf(("CRTDLL: _chgsign not implemented.\n"));
     590  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     591  return FALSE;
     592}
     593
     594
     595/*********************************************************************
     596 *           CRTDLL__chmod   (CRTDLL.54)
     597 */
     598int CDECL CRTDLL__chmod( const char *s, int i)
     599{
     600  dprintf(("CRTDLL: _chmod\n"));
     601  return (_chmod(s, i));
     602}
     603
     604
     605/*********************************************************************
     606 *           CRTDLL__chsize   (CRTDLL.55)
     607 */
     608int CDECL CRTDLL__chsize( int i, long l )
     609{
     610  dprintf(("CRTDLL: _chsize\n"));
     611  return (_chsize(i, l));
     612}
     613
     614
     615/*********************************************************************
     616 *           CRTDLL__clearfp  (CRTDLL.56)
     617 */
     618unsigned int CDECL CRTDLL__clearfp( void )
     619{
     620  dprintf(("CRTDLL: _clearfp\n"));
     621  return (_clear87());
     622}
     623
     624
     625/*********************************************************************
    377626 *           CRTDLL__close   (CRTDLL.57)
    378627 */
    … …  
    396645/*********************************************************************
    397646 *                  CRTDLL__controlfp    (CRTDLL.61)
    398  *      FIXME - Could not find anything about it
    399  */
    400 INT CDECL CRTDLL__controlfp(DWORD ret)
    401 {
    402   dprintf(("CRTDLL: _controlfp not implemented.\n"));
     647 */
     648unsigned CDECL CRTDLL__controlfp(unsigned i1,unsigned i2)
     649{
     650  dprintf(("CRTDLL: _controlfp\n"));
     651  return (_control87(i1, i2));
     652}
     653
     654
     655/*********************************************************************
     656 *                  CRTDLL__copysign    (CRTDLL.62)
     657 */
     658double CDECL CRTDLL__copysign( double x, double y )
     659{
     660  dprintf(("CRTDLL: _copysign not implemented.\n"));
     661  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     662  return FALSE;
     663}
     664
     665
     666/*********************************************************************
     667 *                  CRTDLL__cprintf    (CRTDLL.63)
     668 */
     669INT CDECL CRTDLL__cprintf( char *s, ... )
     670{
     671  dprintf(("CRTDLL: _cprintf not implemented.\n"));
     672  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     673  return FALSE;
     674}
     675
     676
     677/*********************************************************************
     678 *                  CRTDLL__cputs      (CRTDLL.65)
     679 */
     680INT CDECL CRTDLL__cputs( char * s )
     681{
     682  dprintf(("CRTDLL: _cputs\n"));
     683  return (_cputs(s));
     684}
     685
     686
     687/*********************************************************************
     688 *                  CRTDLL__creat      (CRTDLL.66)
     689 */
     690INT CDECL CRTDLL__creat( const char *s, int i )
     691{
     692  dprintf(("CRTDLL: _creat\n"));
     693  return (_creat(s, i));
     694}
     695
     696
     697/*********************************************************************
     698 *                  CRTDLL__cscanf    (CRTDLL.67)
     699 */
     700INT CDECL CRTDLL__cscanf( char *s, ... )
     701{
     702  dprintf(("CRTDLL: _cscanf not implemented.\n"));
    403703  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    404704  return FALSE;
    … …  
    479779
    480780/*********************************************************************
     781 *           CRTDLL__execl   (CRTDLL.79)
     782 */
     783int CDECL CRTDLL__execl( char *s1, char *s2, ...)
     784{
     785  dprintf(("CRTDLL: _execl not implemented.\n"));
     786  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     787  return FALSE;
     788}
     789
     790
     791/*********************************************************************
     792 *           CRTDLL__execle   (CRTDLL.80)
     793 */
     794int CDECL CRTDLL__execle( char *s1, char *s2, ...)
     795{
     796  dprintf(("CRTDLL: _execle not implemented.\n"));
     797  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     798  return FALSE;
     799}
     800
     801
     802/*********************************************************************
     803 *           CRTDLL__execlp   (CRTDLL.81)
     804 */
     805int CDECL CRTDLL__execlp( char *s1, char *s2, ...)
     806{
     807  dprintf(("CRTDLL: _execlp not implemented.\n"));
     808  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     809  return FALSE;
     810}
     811
     812
     813/*********************************************************************
     814 *           CRTDLL__execlpe   (CRTDLL.82)
     815 */
     816int CDECL CRTDLL__execlpe( char *s1, char *s2, ...)
     817{
     818  dprintf(("CRTDLL: _execlpe not implemented.\n"));
     819  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     820  return FALSE;
     821}
     822
     823
     824/*********************************************************************
     825 *           CRTDLL__execv   (CRTDLL.83)
     826 */
     827int CDECL CRTDLL__execv( char *s1, char **s2)
     828{
     829  dprintf(("CRTDLL: _execv\n"));
     830  return (_execv(s1, s2));
     831}
     832
     833
     834/*********************************************************************
     835 *           CRTDLL__execve   (CRTDLL.84)
     836 */
     837int CDECL CRTDLL__execve( char *s1, char **s2, char **s3)
     838{
     839  dprintf(("CRTDLL: _execve\n"));
     840  return (_execve(s1, s2, s3));
     841}
     842
     843
     844/*********************************************************************
     845 *           CRTDLL__execvp   (CRTDLL.85)
     846 */
     847int CDECL CRTDLL__execvp( char *s1, char **s2)
     848{
     849  dprintf(("CRTDLL: _execvp\n"));
     850  return (_execvp(s1, s2));
     851}
     852
     853
     854/*********************************************************************
     855 *           CRTDLL__execvpe   (CRTDLL.86)
     856 */
     857int CDECL CRTDLL__execvpe( char *s1, char **s2, char **s3)
     858{
     859  dprintf(("CRTDLL: _execvpe\n"));
     860  return (_execvpe(s1, s2, s3));
     861}
     862
     863
     864/*********************************************************************
    481865 *                  _exit          (CRTDLL.87)
    482866 */
    … …  
    496880  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    497881  return FALSE;
     882}
     883
     884
     885/*********************************************************************
     886 *           CRTDLL__fcloseall   (CRTDLL.89)
     887 */
     888int CDECL CRTDLL__fcloseall( void )
     889{
     890  dprintf(("CRTDLL: _fcloseall\n"));
     891  return (_fcloseall());
    498892}
    499893
    … …  
    561955
    562956
    563  /*********************************************************************
    564  *                  _findclose    (CRTDLL.098)
    565  */
     957/*********************************************************************
     958 *           CRTDLL__filbuf     (CRTDLL.94)
     959 */
     960int CDECL CRTDLL__filbuf(FILE * f)
     961{
     962  dprintf(("CRTDLL: _filbuf not implemented.\n"));
     963  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     964  return FALSE;
     965}
     966
     967
     968/*********************************************************************
     969 *           CRTDLL__filelength     (CRTDLL.96)
     970 */
     971long CDECL CRTDLL__filelength( int i )
     972{
     973  dprintf(("CRTDLL: _filelength\n"));
     974  return (_filelength(i));
     975}
     976
     977
     978/*********************************************************************
     979 *           CRTDLL__fileno     (CRTDLL.97)
     980 */
     981int CDECL CRTDLL__fileno(FILE * f)
     982{
     983  dprintf(("CRTDLL: _fileno\n"));
     984  return (_fileno(f));
     985}
     986
     987
     988/*********************************************************************
     989*                  _findclose    (CRTDLL.098)
     990*/
    566991int CDECL CRTDLL__findclose( long handle )
    567992{
    … …  
    6061031
    6071032/*********************************************************************
     1033 *                  _flsbuf     (CRTDLL.102)
     1034 */
     1035INT CDECL CRTDLL__flsbuf(int i, FILE * f)
     1036{
     1037  dprintf(("CRTDLL: _flsbuf not implemented.\n"));
     1038  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1039  return FALSE;
     1040}
     1041
     1042
     1043/*********************************************************************
     1044 *                  _flushall     (CRTDLL.103)
     1045 */
     1046INT CDECL CRTDLL__flushall(void)
     1047{
     1048  dprintf(("CRTDLL: _flushall\n"));
     1049  return (_flushall());
     1050}
     1051
     1052
     1053/*********************************************************************
     1054 *                  _fpclass     (CRTDLL.105)
     1055 */
     1056INT CDECL CRTDLL__fpclass( double x )
     1057{
     1058  dprintf(("CRTDLL: _fpclass not implemented.\n"));
     1059  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1060  return FALSE;
     1061}
     1062
     1063
     1064/*********************************************************************
     1065 *                  _fpieee_flt     (CRTDLL.106)
     1066 */
     1067INT CDECL CRTDLL__fpieee_flt( unsigned long exc_code, struct _EXCEPTION_POINTERS *exc_info, int handler)
     1068{
     1069  dprintf(("CRTDLL: _fpieee_flt not implemented.\n"));
     1070  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1071  return FALSE;
     1072}
     1073
     1074
     1075
     1076/*********************************************************************
    6081077 *                  _fpreset     (CRTDLL.107)
    6091078 */
    … …  
    6811150
    6821151/*********************************************************************
     1152 *                  _futime        (CRTDLL.115)
     1153 */
     1154int CDECL CRTDLL__futime( int handle, struct _utimbuf *filetime )
     1155{
     1156  dprintf(("CRTDLL: _futime not implemented.\n"));
     1157  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1158  return FALSE;
     1159}
     1160
     1161
     1162/*********************************************************************
    6831163 *                  _gcvt     (CRTDLL.116)
    6841164 */
    … …  
    7631243
    7641244/*********************************************************************
     1245 *                  _getdrives    (CRTDLL.125)
     1246 */
     1247unsigned long CDECL CRTDLL__getdrives(void)
     1248{
     1249  dprintf(("CRTDLL: _getdrives not implemented.\n"));
     1250  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1251  return FALSE;
     1252}
     1253
     1254
     1255/*********************************************************************
     1256 *                  _getpid    (CRTDLL.126)
     1257 */
     1258int CDECL CRTDLL__getpid( void )
     1259{
     1260  dprintf(("CRTDLL: _getpid\n"));
     1261  return (_getpid());
     1262}
     1263
     1264
     1265/*********************************************************************
    7651266 *                  _getw     (CRTDLL.128)
    7661267 */
    … …  
    8211322  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    8221323  return FALSE;
     1324}
     1325
     1326
     1327/*********************************************************************
     1328 *                  _hypot     (CRTDLL.134)
     1329 */
     1330double CDECL CRTDLL__hypot(double x1, double x2)
     1331{
     1332  dprintf(("CRTDLL: _hypot not implemented.\n"));
     1333  return (_hypot(x1, x2));
    8231334}
    8241335
    … …  
    11281639
    11291640
     1641/*********************************************************************
     1642 *                  _ismbslead     (CRTDLL.162)
     1643 */
     1644int CDECL CRTDLL__ismbslead(const unsigned char *s1, const unsigned char *s2)
     1645{
     1646  dprintf(("CRTDLL: _ismbslead not implemented.\n"));
     1647  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1648  return FALSE;
     1649}
     1650
     1651
     1652/*********************************************************************
     1653 *                  _ismbstrail     (CRTDLL.163)
     1654 */
     1655int CDECL CRTDLL__ismbstrail(const unsigned char *s1, const unsigned char *s2)
     1656{
     1657  dprintf(("CRTDLL: _ismbstrail not implemented.\n"));
     1658  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1659  return FALSE;
     1660}
     1661
     1662
     1663/*********************************************************************
     1664 *                  _isnan     (CRTDLL.164)
     1665 */
     1666int CDECL CRTDLL__isnan( double x )
     1667{
     1668  dprintf(("CRTDLL: _isnan not implemented.\n"));
     1669  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1670  return FALSE;
     1671}
     1672
     1673
     1674/*********************************************************************
     1675 *                  _j0     (CRTDLL.166)
     1676 */
     1677double CDECL CRTDLL__j0(double x)
     1678{
     1679  dprintf(("CRTDLL: _j0\n"));
     1680  return (_j0(x));
     1681}
     1682
     1683
     1684/*********************************************************************
     1685 *                  _j1     (CRTDLL.167)
     1686 */
     1687double CDECL CRTDLL__j1(double x)
     1688{
     1689  dprintf(("CRTDLL: _j1\n"));
     1690  return (_j1(x));}
     1691
     1692
     1693/*********************************************************************
     1694 *                  _jn     (CRTDLL.168)
     1695 */
     1696double CDECL CRTDLL__jn(int i, double x)
     1697{
     1698  dprintf(("CRTDLL: _jn\n"));
     1699  return (_jn(i, x));
     1700}
     1701
     1702
     1703/*********************************************************************
     1704 *                  _kbhit     (CRTDLL.169)
     1705 */
     1706int CDECL CRTDLL__kbhit( void )
     1707{
     1708  dprintf(("CRTDLL: _kbhit\n"));
     1709  return (_kbhit());
     1710}
     1711
     1712
     1713/*********************************************************************
     1714 *                  _lfind     (CRTDLL.170)
     1715 */
     1716void * CDECL CRTDLL__lfind(const void *v1, const void *v2, unsigned int *i1, unsigned int i2,
     1717        int (CDECL *i3)(const void *v3, const void *v4))
     1718{
     1719  dprintf(("CRTDLL: _lfind not implemented.\n"));
     1720  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1721  return FALSE;
     1722//  return (_lfind(v1,v2,i1,i2,i3(v3,v4)));
     1723}
     1724
     1725
    11301726/*******************************************************************
    11311727 *         _local_unwind2  (CRTDLL.172)
    … …  
    11491745
    11501746/*********************************************************************
     1747 *                  _logb     (CRTDLL.174)
     1748 */
     1749double CDECL CRTDLL__logb( double x )
     1750{
     1751  dprintf(("CRTDLL: _logb not implemented.\n"));
     1752  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1753  return FALSE;
     1754}
     1755
     1756
     1757/*********************************************************************
    11511758 *                  _lrotl      (CRTDLL.175)
    11521759 */
    … …  
    11651772  dprintf(("CRTDLL: _lrotr\n"));
    11661773  return (_lrotr(value, shift));
     1774}
     1775
     1776
     1777/*********************************************************************
     1778 *                  _lsearch   (CRTDLL.177)
     1779 */
     1780void * CDECL CRTDLL__lsearch(const void *v1, void  *v2, unsigned int *i1, unsigned int i2,
     1781        int (CDECL *i3)(const void *v3, const void *v4))
     1782{
     1783  dprintf(("CRTDLL: _lsearch not implemented.\n"));
     1784  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     1785  return FALSE;
     1786//  return (_lsearch(v1,v2,i1,i2,i3(v3,v4)));
    11671787}
    11681788
    … …  
    17132333
    17142334/*********************************************************************
     2335 *           CRTDLL__mbstrlen   (CRTDLL.228)
     2336 */
     2337size_t CDECL CRTDLL__mbstrlen(const char *s)
     2338{
     2339  dprintf(("CRTDLL: _mbstrlen not implemented.\n"));
     2340  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     2341  return FALSE;
     2342}
     2343
     2344
     2345/*********************************************************************
    17152346 *           CRTDLL__mbsupr    (CRTDLL.229)
    17162347 */
    … …  
    17182349{
    17192350  dprintf(("CRTDLL: _mbsupr not implemented.\n"));
     2351  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     2352  return FALSE;
     2353}
     2354
     2355
     2356/*********************************************************************
     2357 *           CRTDLL__memccpy   (CRTDLL.230)
     2358 */
     2359void * CDECL CRTDLL__memccpy(void *v1, const void *v2, int i, size_t s)
     2360{
     2361  dprintf(("CRTDLL: _memccpy not implemented.\n"));
    17202362  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    17212363  return FALSE;
    … …  
    17532395  dprintf(("CRTDLL: _msize\n"));
    17542396  return (_msize(ptr));
     2397}
     2398
     2399
     2400/*********************************************************************
     2401 *                  _nextafter        (CRTDLL.235)
     2402 */
     2403double CDECL CRTDLL__nextafter( double x, double y )
     2404{
     2405  dprintf(("CRTDLL: _nextafter not implemented.\n"));
     2406  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     2407  return FALSE;
     2408}
     2409
     2410
     2411/*********************************************************************
     2412 *                  _onexit        (CRTDLL.236)
     2413 */
     2414onexit_t CDECL CRTDLL__onexit(onexit_t t)
     2415{
     2416  dprintf(("CRTDLL: _onexit\n"));
     2417  return (_onexit(t));
    17552418}
    17562419
    … …  
    18742537}
    18752538
     2539
     2540/*********************************************************************
     2541 *                  _putch     (CRTDLL.250)
     2542 */
     2543INT CDECL CRTDLL__putch( int i )
     2544{
     2545  dprintf(("CRTDLL: _putch\n"));
     2546  return (_putch(i));
     2547}
     2548
     2549
     2550/*********************************************************************
     2551 *                  _putenv     (CRTDLL.251)
     2552 */
     2553INT CDECL CRTDLL__putenv(const char *s)
     2554{
     2555  dprintf(("CRTDLL: _putenv\n"));
     2556  return (_putenv(s));
     2557}
     2558
     2559
     2560/*********************************************************************
     2561 *                  _putw     (CRTDLL.252)
     2562 */
     2563INT CDECL CRTDLL__putw( int binint, FILE *fp )
     2564{
     2565  dprintf(("CRTDLL: _putw not implemented.\n"));
     2566  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     2567  return FALSE;
     2568}
     2569
     2570
    18762571/*********************************************************************
    18772572 *                  _read     (CRTDLL.254)
    … …  
    18862581
    18872582/*********************************************************************
    1888  *                  _putw     (CRTDLL.252)
    1889  */
    1890 INT CDECL CRTDLL__putw( int binint, FILE *fp )
    1891 {
    1892   dprintf(("CRTDLL: _putw not implemented.\n"));
    1893   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    1894   return FALSE;
     2583 *                  _rmdir     (CRTDLL.255)
     2584 */
     2585INT CDECL CRTDLL__rmdir(const char *s1)
     2586{
     2587  dprintf(("CRTDLL: _rmdir\n"));
     2588  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     2589  return FALSE;
     2590//  return (_rmdir(s1));
     2591}
     2592
     2593
     2594/*********************************************************************
     2595 *                  _rmtmp     (CRTDLL.256)
     2596 */
     2597INT CDECL CRTDLL__rmtmp(void)
     2598{
     2599  dprintf(("CRTDLL: _rmtmp\n"));
     2600  return(_rmtmp());
    18952601}
    18962602
    … …  
    19142620  return (_rotr(value, shift));
    19152621}
    1916  
     2622
     2623
     2624/*********************************************************************
     2625 *           CRTDLL__scalb       (CRTDLL.259)
     2626 */
     2627double CDECL CRTDLL__scalb( double x, long exp )
     2628{
     2629  dprintf(("CRTDLL: _scalb not implemented.\n"));
     2630  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     2631  return FALSE;
     2632}
     2633
    19172634
    19182635/*********************************************************************
    … …  
    19222639{
    19232640  dprintf(("CRTDLL: _searchenv not implemented.\n"));
     2641  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     2642}
     2643
     2644
     2645/*********************************************************************
     2646 *           CRTDLL__seterrormode        (CRTDLL.261)
     2647 */
     2648void CDECL CRTDLL__seterrormode(int i)
     2649{
     2650  dprintf(("CRTDLL: _seterrormode not implemented.\n"));
    19242651  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    19252652}
    … …  
    19382665/*********************************************************************
    19392666 *                  _setmode           (CRTDLL.263)
    1940  * FIXME: At present we ignore the request to translate CR/LF to LF.
    1941  *
    1942  * We allways translate when we read with fgets, we never do with fread
    1943  *
    19442667 */
    19452668INT CDECL CRTDLL__setmode( INT fh,INT mode)
    19462669{
    1947         /* FIXME */
    1948         dprintf(("on fhandle %d mode %s, STUB.\n",
    1949                       fh,(mode=O_TEXT)?"O_TEXT":
    1950                       (mode=O_BINARY)?"O_BINARY":"UNKNOWN"));
    1951         return -1;
     2670        dprintf(("CRTDLL: _setmode\n"));
     2671        return (_setmode(fh, mode));
    19522672}
    19532673
    … …  
    19642684
    19652685/*********************************************************************
     2686 *           CRTDLL__sopen       (CRTDLL.268)
     2687 */
     2688int CDECL CRTDLL__sopen( const char *s, int i1, int i2, ... )
     2689{
     2690  dprintf(("CRTDLL: _sopen not implemented.\n"));
     2691  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     2692  return FALSE;
     2693}
     2694
     2695
     2696/*********************************************************************
     2697 *           CRTDLL__spawnl      (CRTDLL.269)
     2698 */
     2699int CDECL CRTDLL__spawnl( int i, char *s1, char *s2, ... )
     2700{
     2701  dprintf(("CRTDLL: _spawnl not implemented.\n"));
     2702  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     2703  return FALSE;
     2704}
     2705
     2706
     2707/*********************************************************************
     2708 *           CRTDLL__spawnle     (CRTDLL.270)
     2709 */
     2710int CDECL CRTDLL__spawnle( int i, char *s1, char *s2, ... )
     2711{
     2712  dprintf(("CRTDLL: _spawnle not implemented.\n"));
     2713  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     2714  return FALSE;
     2715}
     2716
     2717
     2718/*********************************************************************
     2719 *           CRTDLL__spawnlp     (CRTDLL.271)
     2720 */
     2721int CDECL CRTDLL__spawnlp( int i, char *s1, char *s2, ... )
     2722{
     2723  dprintf(("CRTDLL: _spawnlp not implemented.\n"));
     2724  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     2725  return FALSE;
     2726}
     2727
     2728
     2729/*********************************************************************
     2730 *           CRTDLL__spawnlpe    (CRTDLL.272)
     2731 */
     2732int CDECL CRTDLL__spawnlpe( int i, char *s1, char *s2, ... )
     2733{
     2734  dprintf(("CRTDLL: _spawnlpe not implemented.\n"));
     2735  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     2736  return FALSE;
     2737}
     2738
     2739
     2740/*********************************************************************
     2741 *           CRTDLL__spawnv      (CRTDLL.273)
     2742 */
     2743int CDECL CRTDLL__spawnv( int i, char *s1, char ** s2 )
     2744{
     2745  dprintf(("CRTDLL: _spawnv\n"));
     2746  return (_spawnv(i, s1, s2));
     2747}
     2748
     2749
     2750/*********************************************************************
     2751 *           CRTDLL__spawnve     (CRTDLL.274)
     2752 */
     2753int CDECL CRTDLL__spawnve( int i, char *s1, char ** s2, char ** s3 )
     2754{
     2755  dprintf(("CRTDLL: _spawnve\n"));
     2756  return (_spawnve(i, s1, s2, s3));
     2757}
     2758
     2759
     2760/*********************************************************************
     2761 *           CRTDLL__spawnvp     (CRTDLL.275)
     2762 */
     2763int CDECL CRTDLL__spawnvp( int i, char *s1, char ** s2 )
     2764{
     2765  dprintf(("CRTDLL: _spawnvp\n"));
     2766  return (_spawnvp(i, s1, s2));
     2767}
     2768
     2769/*********************************************************************
     2770 *           CRTDLL__spawnv      (CRTDLL.276)
     2771 */
     2772int CDECL CRTDLL__spawnvpe( int i, char *s1, char ** s2, char ** s3 )
     2773{
     2774  dprintf(("CRTDLL: _spawnvpe\n"));
     2775  return (_spawnvpe(i, s1, s2, s3));
     2776}
     2777
     2778
     2779/*********************************************************************
    19662780 *           CRTDLL__stat        (CRTDLL.278)
    19672781 */
    … …  
    19742788
    19752789/*********************************************************************
     2790 *           CRTDLL__statusfp    (CRTDLL.279)
     2791 */
     2792unsigned int CDECL CRTDLL__statusfp( void )
     2793{
     2794  dprintf(("CRTDLL: _statusfp\n"));
     2795  return (_status87());
     2796}
     2797
     2798
     2799/*********************************************************************
    19762800 *           CRTDLL__strdate     (CRTDLL.281)
    19772801 */
    … …  
    20002824  dprintf(("CRTDLL: _strdup\n"));
    20012825  return HEAP_strdupA(GetProcessHeap(),0,ptr);
     2826}
     2827
     2828
     2829/*********************************************************************
     2830 *           CRTDLL__strerror    (CRTDLL.284)
     2831 */
     2832char * CDECL CRTDLL__strerror(const char *s)
     2833{
     2834  dprintf(("CRTDLL: _strerror not implemented\n"));
     2835  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     2836  return FALSE;
     2837//  return (_strerror(s));
    20022838}
    20032839
    … …  
    21092945
    21102946/*********************************************************************
     2947 *           CRTDLL__swab        (CRTDLL.299)
     2948 */
     2949void CDECL CRTDLL__swab(char *s1, char *s2, int i)
     2950{
     2951  dprintf(("CRTDLL: _swab\n"));
     2952  _swab(s1, s2, i);
     2953}
     2954
     2955
     2956/*********************************************************************
     2957 *           CRTDLL__tell        (CRTDLL.302)
     2958 */
     2959long CDECL CRTDLL__tell( int i )
     2960{
     2961  dprintf(("CRTDLL: _tell\n"));
     2962  return (_tell(i));
     2963}
     2964
     2965
     2966/*********************************************************************
    21112967 *           CRTDLL__tempnam     (CRTDLL.303)
    21122968 */
    … …  
    21352991  dprintf(("CRTDLL: _toupper\n"));
    21362992  return (_toupper(n));
     2993}
     2994
     2995
     2996/*********************************************************************
     2997 *           CRTDLL__tzset       (CRTDLL.308)
     2998 */
     2999void CDECL CRTDLL__tzset( void )
     3000{
     3001  dprintf(("CRTDLL: _tzset not implemented.\n"));
     3002  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     3003}
     3004
     3005
     3006/*********************************************************************
     3007 *           CRTDLL__umask       (CRTDLL.310)
     3008 */
     3009int CDECL CRTDLL__umask( int i )
     3010{
     3011  dprintf(("CRTDLL: _umask\n"));
     3012  return (_umask(i));
     3013}
     3014
     3015
     3016/*********************************************************************
     3017 *           CRTDLL__ungetch     (CRTDLL.311)
     3018 */
     3019int CDECL CRTDLL__ungetch( int i )
     3020{
     3021  dprintf(("CRTDLL: _ungetch\n"));
     3022  return (_ungetch(i));
    21373023}
    21383024
    … …  
    22733159
    22743160/*********************************************************************
     3161 *                  _y0     (CRTDLL.332)
     3162 */
     3163double CDECL CRTDLL__y0(double x)
     3164{
     3165  dprintf(("CRTDLL: _y0\n"));
     3166  return (_y0(x));
     3167}
     3168
     3169
     3170/*********************************************************************
     3171 *                  _y1     (CRTDLL.333)
     3172 */
     3173double CDECL CRTDLL__y1(double x)
     3174{
     3175  dprintf(("CRTDLL: _y1\n"));
     3176  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     3177  return (_y1(x));
     3178}
     3179
     3180
     3181/*********************************************************************
     3182 *                  _yn     (CRTDLL.334)
     3183 */
     3184double CDECL CRTDLL__yn(int i, double x)
     3185{
     3186  dprintf(("CRTDLL: _yn\n"));
     3187  return (_yn(i, x));
     3188}
     3189
     3190
     3191/*********************************************************************
    22753192 *                  isleadbyte  (CRTDLL.335)
    22763193 */
Note: See TracChangeset for help on using the changeset viewer.