Changeset 4667 for trunk/src

Timestamp:

Nov 22, 2000, 12:49:04 AM (25 years ago)

Author:

phaller

Message:

Major move towards WINE CRTDLL, mixture between both code branches

Location:

trunk/src/crtdll

Files:

• crt_mb.cpp (deleted)
• crt_string.cpp (modified) (9 diffs)
• crt_wc.cpp (modified) (14 diffs)
• crtdll.cpp (modified) (49 diffs)
• crtdll.h (added)
• crtdll_main.c (added)
• dir.c (added)
• exit.c (added)
• file.c (added)
• makefile (modified) (4 diffs)
• mbstring.c (added)
• memory.c (added)
• old (added)
• old/asmhlp.asm (added)
• old/asmhlp.h (added)
• old/crt_mb.cpp (added)
• old/crt_memory.cpp (added)
• old/crt_string.cpp (added)
• old/crt_wc.cpp (added)
• old/crtdll.cpp (added)
• old/crtdll.def (added)
• old/crtdllrsrc.orc (added)
• old/crtimps.h (added)
• old/crtinc.h (added)
• old/initterm.cpp (added)
• old/internal.cpp (added)
• old/makefile (added)
• old/stubs.cpp (added)
• spawn.c (added)
• stubs.cpp (modified) (9 diffs)

trunk/src/crtdll/crt_string.cpp

@@ -1 @@
-/* $Id: crt_string.cpp,v 1.2 2000-02-21 10:34:01 sandervl Exp $ */
+/* $Id: crt_string.cpp,v 1.3 2000-11-21 23:48:49 phaller Exp $ */
 
 /*
@@ -13 +13 @@
  * Copyright 1999-2000 Jens Wiessner
  *
- * CRTDLL - string functions
- *
+ * Implementation Notes:
+ * MT Safe.
  */
 
@@ -24 +24 @@
 
 
+#include "crtdll.h"
+
+
+DEFAULT_DEBUG_CHANNEL(crtdll);
+
 /*********************************************************************
  *           _strcmpi            (CRTDLL.280)
@@ -48 +53 @@
 
 /*********************************************************************
- *           CRTDLL__strdec      (CRTDLL.282)
- */
-char * CDECL CRTDLL__strdec( const char *, const char *p ) 
-{
-  dprintf2(("CRTDLL: _strdec\n"));
-  return( (char *)(p-1) );
-}
-
-
-/*********************************************************************
- *           CRTDLL__strdup      (CRTDLL.283)
- */
-LPSTR CDECL CRTDLL__strdup(LPCSTR ptr)
-{
-  dprintf2(("CRTDLL: _strdup\n"));
-  return HEAP_strdupA(GetProcessHeap(),0,ptr);
-}
-
-
-/*********************************************************************
- *           _strerror           (CRTDLL.284)
- */
-char * CDECL CRTDLL__strerror(const char *s)
-{
-  dprintf(("CRTDLL: _strerror\n"));
-  return (_strerror((char*)s));
-}
-
-
-/*********************************************************************
  *           _stricmp    (CRTDLL.285)
  */
@@ -99 +74 @@
   dprintf2(("CRTDLL: _stricoll\n"));
   return stricmp(s1,s2);
-}
-
-
-/*********************************************************************
- *           CRTDLL__strinc      (CRTDLL.287)
- */
-char * CDECL CRTDLL__strinc( const char *p )
-{
-    dprintf2(("CRTDLL: _strinc\n"));
-    return( (char *)(p+1) );
 }
 
@@ -132 +97 @@
 
 /*********************************************************************
- *           CRTDLL__strncnt     (CRTDLL.289)
- */
-size_t CDECL CRTDLL__strncnt( const char *p, size_t l ) 
-{
-    dprintf2(("CRTDLL: _strncnt\n"));
-    size_t i;
-    i = strlen(p);
-    return( (i>l) ? l : i );
-}
-
-
-/*********************************************************************
- *           CRTDLL__strnextc    (CRTDLL.290)
- */
-unsigned int CDECL CRTDLL__strnextc( const char *p )
-{
-    dprintf2(("CRTDLL: _strnextc\n"));
-    return( (unsigned int)*p );
-}
-
-
-/*********************************************************************
  *           CRTDLL__strnicmp    (CRTDLL.291)
  */
@@ -167 +110 @@
 }
 
-
-/*********************************************************************
- *           CRTDLL__strninc     (CRTDLL.292)
- */
-char * CDECL CRTDLL__strninc( const char *p, size_t l )
-{
-    dprintf2(("CRTDLL: _strninc\n"));
-    return( (char *)(p+l) );
-}
-
-
-/*********************************************************************
- *           CRTDLL__strnset     (CRTDLL.293)
- */
-char * CDECL CRTDLL__strnset(char *string, int c, size_t count)
-{
-  dprintf2(("CRTDLL: _strnset\n"));
-  char *dst;
-
-  dst = string;
-  while (count > 0 && *dst != 0)
-    {
-      *dst++ = (char)c;
-      --count;
-    }
-  return string;
-}
-
-
-/*********************************************************************
- *           CRTDLL__strrev      (CRTDLL.294)
- */
-char * CDECL CRTDLL__strrev( char *string )
-{
-  dprintf2(("CRTDLL: _strrev\n"));
-  char *p, *q, c;
-
-  p = q = string;
-  while (*q != 0)
-    ++q;
-  --q;                                  /* Benign, as string must be != 0 */
-  while ((size_t)q > (size_t)p)
-    {
-      c = *p; *p = *q; *q = c;
-      ++p; --q;
-    }
-  return string;
-}
-
-
-/*********************************************************************
- *           CRTDLL__strset      (CRTDLL.295)
- */
-char * CDECL CRTDLL__strset(char *string, int c)
-{
-  dprintf2(("CRTDLL: _strset\n"));
-  char *dst;
-
-  dst = string;
-  while (*dst != 0)
-    *dst++ = (char)c;
-  return string;
-}
-
-
-/*********************************************************************
- *           CRTDLL__strspnp     (CRTDLL.296)
- */
-char * CDECL CRTDLL__strspnp( const char *p1, const char *p2 ) 
-{
-    dprintf2(("CRTDLL: _strspnp\n"));
-    return( (*(p1 += strspn(p1,p2))!='\0') ? (char*)p1 : NULL );
-}
 
 
@@ -348 +218 @@
 
 /*********************************************************************
- *                  strerror        (CRTDLL.465)
- */
-char * CDECL CRTDLL_strerror( int errnum )
-{
-  dprintf2(("CRTDLL: strerror\n"));
-  return strerror(errnum);
-}
-
-
-/*********************************************************************
  *                  strftime        (CRTDLL.466)
  */
@@ -531 +391 @@
   return strxfrm(s1, s2, n);
 }
+
+
+/* INTERNAL: CRTDLL_malloc() based strndup */
+LPSTR __CRTDLL__strndup(LPSTR buf, INT size);
+LPSTR __CRTDLL__strndup(LPSTR buf, INT size)
+{
+  char* ret;
+  int len = strlen(buf);
+  int max_len;
+
+  max_len = size <= len? size : len + 1;
+
+  ret = (char*)CRTDLL_malloc(max_len);
+  if (ret)
+  {
+    memcpy(ret,buf,max_len);
+    ret[max_len] = 0;
+  }
+  return ret;
+}
+
+
+/*********************************************************************
+ *                  _strdec           (CRTDLL.282)
+ *
+ * Return the byte before str2 while it is >= to str1. 
+ *
+ * PARAMS
+ *   str1 [in]  Terminating string
+ *
+ *   sre2 [in]  string to start searching from
+ *
+ * RETURNS
+ *   The byte before str2, or str1, whichever is greater
+ *
+ * NOTES
+ * This function is implemented as tested with windows, which means
+ * it does not have a terminating condition. It always returns
+ * the byte before str2. Use with extreme caution!
+ */
+LPSTR CDECL CRTDLL__strdec(LPSTR str1, LPSTR str2)
+{
+  /* Hmm. While the docs suggest that the following should work... */
+  /*  return (str2<=str1?0:str2-1); */
+  /* ...Version 2.50.4170 (NT) from win98 constantly decrements! */
+  return str2-1;
+}
+
+
+/*********************************************************************
+ *                  _strdup          (CRTDLL.285)
+ *
+ * Duplicate a string.
+ */
+LPSTR CDECL CRTDLL__strdup(LPCSTR ptr)
+{
+    LPSTR ret = (LPSTR)CRTDLL_malloc(strlen(ptr)+1);
+    if (ret) strcpy( ret, ptr );
+    return ret;
+}
+
+
+/*********************************************************************
+ *                  _strinc           (CRTDLL.287)
+ *
+ * Return a pointer to the next character in a string
+ */
+LPSTR CDECL CRTDLL__strinc(LPSTR str)
+{
+  return str+1;
+}
+
+
+/*********************************************************************
+ *                   _strnextc         (CRTDLL.290)
+ *
+ * Return an unsigned int from a string.
+ */
+UINT CDECL CRTDLL__strnextc(LPCSTR str)
+{
+  return (UINT)*str;
+}
+
+
+/*********************************************************************
+ *                  _strninc           (CRTDLL.292)
+ *
+ * Return a pointer to the 'n'th character in a string
+ */
+LPSTR CDECL CRTDLL__strninc(LPSTR str, INT n)
+{
+  return str+n;
+}
+
+
+/*********************************************************************
+ *                  _strnset           (CRTDLL.293)
+ *
+ * Fill a string with a character up to a certain length
+ */
+LPSTR CDECL CRTDLL__strnset(LPSTR str, INT c, INT len)
+{
+  if (len > 0 && str)
+    while (*str && len--)
+      *str++ = c;
+  return str;
+}
+
+
+/*********************************************************************
+ *                  _strrev              (CRTDLL.294)
+ *
+ * Reverse a string in place
+ */
+LPSTR CDECL CRTDLL__strrev (LPSTR str)
+{
+  LPSTR p1;
+  LPSTR p2;
+ 
+  if (str && *str)
+    for (p1 = str, p2 = str + strlen(str) - 1; p2 > p1; ++p1, --p2)
+    {
+      *p1 ^= *p2;
+      *p2 ^= *p1;
+      *p1 ^= *p2;
+    }
+
+  return str;
+}
+
+/*********************************************************************
+ *                  _strset          (CRTDLL.295)
+ *
+ * Fill a string with a value.
+ */
+LPSTR  CDECL CRTDLL__strset (LPSTR str, INT set)
+{
+  char *ptr = str;
+
+  while (*ptr)
+    *ptr++ = set;
+
+  return str;
+}
+
+
+/*********************************************************************
+ *                  _strncnt           (CRTDLL.289)
+ *
+ * Return the length of a string or the maximum given length.
+ */
+LONG CDECL CRTDLL__strncnt(LPSTR str, LONG max)
+{
+  LONG len = strlen(str);
+  return (len > max? max : len);
+}
+
+
+/*********************************************************************
+ *                  _strspnp           (CRTDLL.296)
+ *
+ */
+LPSTR CDECL CRTDLL__strspnp(LPSTR str1, LPSTR str2)
+{
+  str1 += strspn(str1,str2);
+  return *str1? str1 : 0;
+}
+
+
+/*********************************************************************
+ *                  _swab           (CRTDLL.299)
+ *
+ * Copy from source to dest alternating bytes (i.e 16 bit big-to-little
+ * endian or vice versa).
+ */
+void CDECL CRTDLL__swab(LPSTR src, LPSTR dst, INT len)
+{
+  //_swab(s1, s2, i);
+  
+  if (len > 1)
+  {
+    len = (unsigned)len >> 1;
+
+    while (len--) {
+      *dst++ = src[1];
+      *dst++ = *src++;
+      src++;
+    }
+  }
+}

trunk/src/crtdll/crt_wc.cpp

@@ -1 @@
-/* $Id: crt_wc.cpp,v 1.2 2000-02-21 23:11:30 sandervl Exp $ */
+/* $Id: crt_wc.cpp,v 1.3 2000-11-21 23:48:49 phaller Exp $ */
 
 /*
@@ -253 +253 @@
 {
   dprintf2(("CRTDLL: iswalnum(%08xh)\n", i));
+  //return get_char_typeW(wc) & (C1_ALPHA|C1_DIGIT|C1_LOWER|C1_UPPER);
   return (iswalnum(i));
 }
@@ -264 +265 @@
   dprintf2(("CRTDLL: iswalpha(%08xh)\n", i));
   return (iswalpha(i));
-}
-
-
-/*********************************************************************
- *                  iswascii    (CRTDLL.404)
- */
-int CDECL CRTDLL_iswascii(wint_t c)
-{
-  dprintf2(("CRTDLL: iswascii\n", c));
-  return  (!((c)&(~0x7f)));
+  //return get_char_typeW(wc) & (C1_ALPHA|C1_LOWER|C1_UPPER);
 }
 
@@ -283 +275 @@
 {
   dprintf2(("CRTDLL: iswcntrl(%08xh)\n", i));
+  //return get_char_typeW(wc) & C1_CNTRL;
   return (iswcntrl(i));
 }
@@ -303 +296 @@
 {
   dprintf2(("CRTDLL: iswdigit(%08xh)\n", i));
+  //return get_char_typeW(wc) & C1_DIGIT;
   return (iswdigit(i));
 }
@@ -313 +307 @@
 {
   dprintf2(("CRTDLL: iswgraph(%08xh)\n", i));
+  //return get_char_typeW(wc) & (C1_ALPHA|C1_PUNCT|C1_DIGIT|C1_LOWER|C1_UPPER);
   return (iswgraph(i));
 }
@@ -323 +318 @@
 {
   dprintf2(("CRTDLL: iswlower(%08xh)\n", i));
+  //return get_char_typeW(wc) & C1_LOWER;
   return (iswlower(i));
 }
@@ -333 +329 @@
 {
   dprintf2(("CRTDLL: iswprint(%08xh)\n", i));
+  //return get_char_typeW(wc) & (C1_ALPHA|C1_BLANK|C1_PUNCT|C1_DIGIT|C1_LOWER|C1_UPPER);
   return (iswprint(i));
 }
@@ -343 +340 @@
 {
   dprintf2(("CRTDLL: iswpunct(%08xh)\n", i));
+  //return get_char_typeW(wc) & C1_PUNCT;
   return (iswpunct(i));
 }
@@ -353 +351 @@
 {
   dprintf2(("CRTDLL: iswspace(%08xh)\n", i));
+  //return get_char_typeW(wc) & C1_SPACE;
   return (iswspace(i));
 }
@@ -363 +362 @@
 {
   dprintf2(("CRTDLL: iswupper(%08xh)\n", i));
+  //return get_char_typeW(wc) & C1_UPPER;
   return (iswupper(i));
 }
@@ -373 +373 @@
 {
   dprintf2(("CRTDLL: iswxdigit(%08xh)\n", i));
+  //return get_char_typeW(wc) & C1_XDIGIT;
   return (iswxdigit(i));
 }
@@ -448 +449 @@
 
 /*********************************************************************
- *                  vswprintf       (CRTDLL.498)
- */
-int CDECL CRTDLL_vswprintf( wchar_t *s , size_t t, const wchar_t *format, va_list arg )
-{
-  dprintf2(("CRTDLL: vswprintf\n"));
-  return (vswprintf(s, t, format, arg));
-}
-
-
-/*********************************************************************
  *                  wcscat            (CRTDLL.500)
  */
@@ -731 +722 @@
 {
   dprintf2(("CRTDLL: wctomb\n"));
+  //return WideCharToMultiByte( CP_ACP, 0, &ch, 1, dst, 6, NULL, NULL );
   return (wctomb((char*)dst,ch));
 }

trunk/src/crtdll/crtdll.cpp

@@ -1 @@
-/* $Id: crtdll.cpp,v 1.26 2000-06-21 18:39:32 phaller Exp $ */
+/* $Id: crtdll.cpp,v 1.27 2000-11-21 23:48:49 phaller Exp $ */
 
 /*
@@ -67 +67 @@
 
 
-
-#define FS_OS2   unsigned short sel = RestoreOS2FS();
-#define FS_WIN32 SetFS(sel);
-
 #define dprintf2 dprintf
-
-
-/*********************************************************************
- *                  CRTDLL_MainInit  (CRTDLL.init)
- */
-BOOL WINAPI CRTDLL_Init(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
-{
-  FS_OS2
-    
-    if (fdwReason == DLL_PROCESS_ATTACH) {
-      _fdopen(0,"r");
-      _fdopen(1,"w");
-      _fdopen(2,"w");
-      CRTDLL_hHeap = HeapCreate(0, 0x10000, 0);
-    }
-    else
-      if (fdwReason == DLL_PROCESS_DETACH) {
-        HeapDestroy(CRTDLL_hHeap);
-        CRTDLL_hHeap = 0;
-      }
-  
-  FS_WIN32
-  return TRUE;
-}
-
-
-/*********************************************************************
- *                  new           (CRTDLL.001)
- */
-VOID* CDECL CRTDLL_new(DWORD size)
-{
-    dprintf2(("CRTDLL: ??2@YAPAXI@Z\n"));
-    VOID* result;
-    if(!(result = Heap_Alloc(size)) && new_handler)
-        (*new_handler)();
-    return result;
-}
-
-
-/*********************************************************************
- *                  delete       (CRTDLL.002)
- */
-VOID CDECL CRTDLL_delete(VOID* ptr)
-{
-    dprintf2(("CRTDLL: ??3@YAXPAX@Z\n"));
-    Heap_Free(ptr);
-}
-
-
-/*********************************************************************
- *                  set_new_handler(CRTDLL.003)
- */
-new_handler_type CDECL CRTDLL_set_new_handler(new_handler_type func)
-{
-    dprintf2(("CRTDLL: ?_set_new_handler@@YAP6AHI@ZP6AHI@Z@Z\n"));
-    new_handler_type old_handler = new_handler;
-    new_handler = func;
-    return old_handler;
-}
 
 
@@ -341 +278 @@
 
 /*********************************************************************
- *                  _GetMainArgs  (CRTDLL.22)
- */
-DWORD CDECL CRTDLL__GetMainArgs(LPDWORD argc,LPSTR **argv,
-                                LPSTR *environ,DWORD flag)
-{
-        char *cmdline;
-        char  **xargv;
-        int     xargc,i,afterlastspace;
-        DWORD   version;
-
-        dprintf2(("CRTDLL: GetMainArgs\n"));
-
-        CRTDLL_acmdln_dll = cmdline = HEAP_strdupA( GetProcessHeap(), 0,
-                                                    GetCommandLineA() );
-
-        version = GetVersion();
-        CRTDLL_osver_dll       = version >> 16;
-        CRTDLL_winminor_dll    = version & 0xFF;
-        CRTDLL_winmajor_dll    = (version>>8) & 0xFF;
-        CRTDLL_baseversion_dll = version >> 16;
-        CRTDLL_winver_dll      = ((version >> 8) & 0xFF) + ((version & 0xFF) << 8);
-        CRTDLL_baseminor_dll   = (version >> 16) & 0xFF;
-        CRTDLL_basemajor_dll   = (version >> 24) & 0xFF;
-        CRTDLL_osversion_dll   = version & 0xFFFF;
-        CRTDLL_osminor_dll     = version & 0xFF;
-        CRTDLL_osmajor_dll     = (version>>8) & 0xFF;
-
-        /* missing threading init */
-
-        i=0;xargv=NULL;xargc=0;afterlastspace=0;
-/*
-        while (cmdline[i]) {
-                if (cmdline[i]==' ') {
-                        xargv=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv,
-                                                   sizeof(char*)*(++xargc));
-                        cmdline[i]='\0';
-                        xargv[xargc-1] = HEAP_strdupA( GetProcessHeap(), 0,
-                                                       cmdline+afterlastspace);
-                        i++;
-                        while (cmdline[i]==' ')
-                                i++;
-                        if (cmdline[i])
-                                afterlastspace=i;
-
-                } else
-                        i++;
-
-        }
-
-        xargv=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv,
-                                   sizeof(char*)*(++xargc));
-        cmdline[i]='\0';
-        xargv[xargc-1] = HEAP_strdupA( GetProcessHeap(), 0,
-                                       cmdline+afterlastspace);
-*/
-        CRTDLL_argc_dll = xargc;
-        *argc           = xargc;
-        CRTDLL_argv_dll = xargv;
-        *argv           = xargv;
-        CRTDLL_environ_dll = *environ = GetEnvironmentStringsA();
-        dprintf2(("CRTDLL: GetMainArgs end\n"));
-        return 0;
-}
-
-
-/*********************************************************************
- *                  __doserrno            (CRTDLL.26)
- */
-int * CDECL CRTDLL___doserrno()
-{       
-        dprintf2(("CRTDLL: __doserrno\n"));
-        return (__doserrno());
-}
-
-
-/*********************************************************************
- *           CRTDLL___isascii   (CRTDLL.28)
- */
-int CDECL CRTDLL___isascii(int i)
-{
-  //TODO: Check if really ok.
-  dprintf(("CRTDLL: __isascii -> _isascii\n"));
-  return (_isascii(i));
-}
-
-
-/*********************************************************************
- *           CRTDLL___iscsym   (CRTDLL.29)
- */
-int CDECL CRTDLL___iscsym(int c)
-{
-  //TODO: Check if really ok.
-  dprintf(("CRTDLL: __iscsym -> _iscsym\n"));
-  return (_iscsym(c));
-}
-
-
-/*********************************************************************
- *           CRTDLL___iscsymf   (CRTDLL.30)
- */
-int CDECL CRTDLL___iscsymf(int c)
-{
-  //TODO: Check if really ok.
-  dprintf(("CRTDLL: __iscsymf -> _iscsymf\n"));
-  return (_iscsymf(c));
-}
-
-
-/*********************************************************************
  *           CRTDLL___threadhandle   (CRTDLL.33)
  */
@@ -466 +294 @@
   dprintf2(("CRTDLL: __threadid\n"));
   return GetCurrentThreadId();
-}
-
-
-/*********************************************************************
- *           CRTDLL__access   (CRTDLL.37)
- */
-int CDECL CRTDLL__access(const char *path,int mode)
-{
-  dprintf2(("CRTDLL: _access\n"));
-  return (_access(path, mode));
-}
-
-
-/*********************************************************************
- *           CRTDLL___toascii   (CRTDLL.38)
- */
-int CDECL CRTDLL___toascii(int c)
-{
-  //TODO: Check if really ok.
-  dprintf(("CRTDLL: __toascii -> _toascii\n"));
-  return (_toascii(c));
-}
-
-
-/*********************************************************************
- *                  _aexit_rtn_dll    (CRTDLL.39)
- */
-VOID CDECL CRTDLL__aexit_rtn_dll(int exitcode)
-{
-  dprintf2(("CRTDLL: _aexit_rtn_dll\n"));
-  ExitProcess(exitcode);
-}
-
-
-/*********************************************************************
- *                  _amsg_exit    (CRTDLL.40)
- */
-VOID CDECL CRTDLL__amsg_exit(int errnum)
-{
-  dprintf2(("CRTDLL: _amsg_exit\n"));
-  fprintf(stderr,strerror(errnum));
-  ExitProcess(-1);
-}
-
-
-/*********************************************************************
- *           CRTDLL__assert   (CRTDLL.41)
- */
-void CDECL CRTDLL__assert( char *s1, char *s2, int i)
-{
-  dprintf2(("CRTDLL: _assert\n"));
-  _assert(s1, s2, i);
-}
-
-
-/*********************************************************************
- *                  CRTDLL__beep                    (CRTDLL.45)
- */
-void CDECL CRTDLL__beep(unsigned nFreq, unsigned nDur)
-{       
-  dprintf2(("_beep\n"));
-  Beep(nFreq,nDur);
 }
 
@@ -591 +357 @@
 
 /*********************************************************************
- *                  _c_exit          (CRTDLL.47)
- *
- */
-void CDECL CRTDLL__c_exit(INT ret)
-{
-        dprintf2(("_c_exit(%d)\n",ret));
-        ExitProcess(ret);
-}
-
-
-/*********************************************************************
- *           _cabs   (CRTDLL.48)
- */
-double CDECL CRTDLL__cabs(struct complex z)
-{
-  dprintf2(("CRTDLL: _cabs\n"));
-  return (_cabs(z));
-}
-
-
-/*********************************************************************
- *                  _cexit          (CRTDLL.49)
- */
-void CDECL CRTDLL__cexit(INT ret)
-{
-  dprintf2(("_cexit(%d)\n",ret));
-  ExitProcess(ret);
-}
-
-
-/*********************************************************************
  *           CRTDLL__cgets  (CRTDLL.50)
  */
@@ -632 +367 @@
 
 /*********************************************************************
- *                  _chdir           (CRTDLL.51)
- */
-INT CDECL CRTDLL__chdir(LPCSTR newdir)
-{
-        dprintf2(("CRTDLL: _chdir\n"));
-        if (!SetCurrentDirectoryA(newdir))
-                return 1;
-        return 0;
-}
-
-
-/*********************************************************************
- *                  _chdrive           (CRTDLL.52)
- *
- *  newdir      [I] drive to change to, A=1
- *
- */
-BOOL CDECL CRTDLL__chdrive(INT newdrive)
-{
-        /* FIXME: generates errnos */
-        dprintf2(("CRTDLL: _chdrive\n"));
-        return DRIVE_SetCurrentDrive(newdrive-1);
-}
-
-
-/*********************************************************************
  *           CRTDLL__chmod   (CRTDLL.54)
  */
@@ -688 +397 @@
 
 /*********************************************************************
- *           CRTDLL__close   (CRTDLL.57)
- */
-int CDECL CRTDLL__close(int handle)
-{
-  dprintf2(("CRTDLL: _close\n"));
-  
-  return CloseHandle(handle);
-}
-
-
-/*********************************************************************
  *           CRTDLL__control87   (CRTDLL.60)
  */
@@ -739 +437 @@
 
 /*********************************************************************
- *                  CRTDLL__creat      (CRTDLL.66)
- */
-INT CDECL CRTDLL__creat( const char *s, int i )
-{
-  dprintf2(("CRTDLL: _creat\n"));
-  return (_creat(s, i));
-}
-
-
-/*********************************************************************
  *      _cscanf                                 (CRTDLL.67)
  */
@@ -809 +497 @@
 
 /*********************************************************************
- *           _eof   (CRTDLL.76)
- */
-int CDECL CRTDLL__eof( int _fd )
-{
-  dprintf2(("CRTDLL: _eof\n"));
-  return (__eof(_fd));
-}
-
-
-/*********************************************************************
- *           CRTDLL__errno  (CRTDLL.77)
- */
-int * CDECL CRTDLL__errno(void)
-{
-  dprintf2(("CRTDLL: _errno\n"));
-  return (_errno());
-}
-
-
-/*********************************************************************
- *                  _except_handler2  (CRTDLL.78)
- */
-INT CDECL CRTDLL__except_handler2 ( PEXCEPTION_RECORD rec,
-        PEXCEPTION_FRAME frame, PCONTEXT context, 
-        PEXCEPTION_FRAME  *dispatcher)
-{
-        dprintf (("exception %lx flags=%lx at %p handler=%p %p %p stub\n",
-        rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress,
-        frame->Handler, context, dispatcher));
-        return ExceptionContinueSearch;
-}
-
-
-/*********************************************************************
  *           _execl   (CRTDLL.79)
  */
@@ -923 +577 @@
 
 /*********************************************************************
- *                  _exit          (CRTDLL.87)
- */
-VOID CDECL CRTDLL__exit(DWORD ret)
-{
-        dprintf2(("CRTDLL: _exit\n"));
-        ExitProcess(ret);
-}
-
-
-/*********************************************************************
- *           _fcloseall   (CRTDLL.89)
- */
-int CDECL CRTDLL__fcloseall( void )
-{
-  dprintf2(("CRTDLL: _fcloseall\n"));
-  return (_fcloseall());
-}
-
-
-/*********************************************************************
  *           _fcvt  (CRTDLL.90)
  */
@@ -953 +587 @@
 
 /*********************************************************************
- *                  _fdopen     (CRTDLL.91)
- */
-FILE * CDECL CRTDLL__fdopen(INT handle, LPCSTR mode)
-{
-    dprintf2(("CRTDLL: _fdopen\n"));
-    return (_fdopen(handle, mode));
-}
-
-
-/*********************************************************************
- *           _fgetchar  (CRTDLL.92)
- */
-int CDECL CRTDLL__fgetchar( void )
-{
-  dprintf2(("CRTDLL: _fgetchar\n"));
-  return (_fgetchar());
-}
-
-
-/*********************************************************************
  *           CRTDLL__filelength     (CRTDLL.96)
  */
@@ -979 +593 @@
   dprintf2(("CRTDLL: _filelength\n"));
   return (_filelength(i));
-}
-
-
-/*********************************************************************
- *           _fileno     (CRTDLL.97)
- */
-int CDECL CRTDLL__fileno(FILE * f)
-{
-  dprintf2(("CRTDLL: _fileno\n"));
-  return (_fileno(f));
-}
-
-
-/*********************************************************************
- *                  _flushall     (CRTDLL.103)
- */
-INT CDECL CRTDLL__flushall(void)
-{
-  dprintf2(("CRTDLL: _flushall\n"));
-  return (_flushall());
-}
-
-
-/*********************************************************************
- *      _fpreset                                (CRTDLL.107)
- */
-void CDECL CRTDLL__fpreset(void)
-{
-  dprintf(("CRTDLL: _fpreset\n"));
-  _fpreset();
-}
-
-
-/*********************************************************************
- *                  _fputchar     (CRTDLL.108)
- */
-INT CDECL CRTDLL__fputchar( int c )
-{
-  dprintf2(("CRTDLL: _fputchar\n"));
-  return(_fputchar(c));
-}
-
-
-/*********************************************************************
- *      _fstat                                  (CRTDLL.111)
- */
-int CDECL CRTDLL__fstat(int file, struct stat* buf)
-{
-  dprintf(("CRTDLL: _fstat\n"));
-  return (_fstat(file, buf));
 }
 
@@ -1056 +620 @@
 
 /*********************************************************************
- *                  _fullpath     (CRTDLL.114)
- */
-char * CDECL CRTDLL__fullpath( char *buf, char *path, size_t size )
-{
-  dprintf2(("CRTDLL: _fullpath\n"));
-  return (_fullpath(buf, path, size));
-}
-
-
-/*********************************************************************
  *                  _gcvt     (CRTDLL.116)
  */
@@ -1092 +646 @@
   dprintf2(("CRTDLL: _getche\n"));
   return (_getche());
-}
-
-
-/*********************************************************************
- *                  _getcwd     (CRTDLL.120)
- */
-char * CDECL CRTDLL__getcwd( char *buf, size_t size )
-{
-  dprintf2(("CRTDLL: _getcwd\n"));
-  return (_getcwd(buf, size));
-}
-
-
-/*********************************************************************
- *                  _getdcwd     (CRTDLL.121)
- */
-char * CDECL CRTDLL__getdcwd( int drive, char *buffer, size_t maxlen )
-{
-  dprintf2(("CRTDLL: _getdcwd\n"));
-  return (_getdcwd(drive, buffer, maxlen));
-}
-
-
-/*********************************************************************
- *                  _getdrive    (CRTDLL.124)
- */
-unsigned CDECL CRTDLL__getdrive( void )
-{
-  dprintf2(("CRTDLL: _getdrive\n"));
-  return DRIVE_GetCurrentDrive() + 1;
 }
 
@@ -1181 +705 @@
 
 
-/*******************************************************************
- *         _global_unwind2  (CRTDLL.129)
- */
-void CDECL CRTDLL__global_unwind2( PEXCEPTION_FRAME frame )
-{
-    dprintf2(("CRTDLL: _global_unwind2\n"));
-    RtlUnwind( frame, 0, NULL, 0 );
-}
-
-
-/*********************************************************************
- *                  _heapchk    (CRTDLL.130)
- */
-int CDECL CRTDLL__heapchk( void )
-{
-  dprintf2(("CRTDLL: _heapchk\n"));
-  return (_heapchk());
-}
-
-
-/*********************************************************************
- *                  _heapmin    (CRTDLL.131)
- */
-int CDECL CRTDLL__heapmin( void )
-{
-  dprintf2(("CRTDLL: _heapmin\n"));
-  return (_heapmin());
-}
-
-
-/*********************************************************************
- *                  _heapset    (CRTDLL.132)
- */
-int CDECL CRTDLL__heapset( unsigned int fill )
-{
-  dprintf2(("CRTDLL: _heapset\n"));
-  return (_heapset(fill));
-}
-
-
 /*********************************************************************
  *                  _hypot     (CRTDLL.134)
@@ -1228 +712 @@
   dprintf2(("CRTDLL: _hypot\n"));
   return (_hypot(x1, x2));
-}
-
-
-/*********************************************************************
- *                  _initterm     (CRTDLL.135)
- */
-DWORD CDECL CRTDLL__initterm(_INITTERMFUN *start,_INITTERMFUN *end)
-{
-        dprintf2(("CRTDLL: initterm\n"));
-        _INITTERMFUN    *current;
-
-        current=start;
-        while (current<end) {
-                if (*current) (*current)();
-                current++;
-        }
-        return 0;
-}
-
-
-/*********************************************************************
- *                  _isctype           (CRTDLL.138)
- */
-BOOL CDECL CRTDLL__isctype(CHAR x,CHAR type)
-{
-        dprintf2(("CRTDLL: isctype\n"));
-        if ((type & CRTDLL_SPACE) && isspace(x))
-                return TRUE;
-        if ((type & CRTDLL_PUNCT) && ispunct(x))
-                return TRUE;
-        if ((type & CRTDLL_LOWER) && islower(x))
-                return TRUE;
-        if ((type & CRTDLL_UPPER) && isupper(x))
-                return TRUE;
-        if ((type & CRTDLL_ALPHA) && isalpha(x))
-                return TRUE;
-        if ((type & CRTDLL_DIGIT) && isdigit(x))
-                return TRUE;
-        if ((type & CRTDLL_CONTROL) && iscntrl(x))
-                return TRUE;
-        /* check CRTDLL_LEADBYTE */
-        return FALSE;
 }
 
@@ -1326 +768 @@
 
 /*********************************************************************
- *                  _loaddll    (CRTDLL.171)
- */
-void * CDECL CRTDLL__loaddll (char *name)
-{
-  dprintf2(("CRTDLL: _loaddll\n"));
-  return (void*)LoadLibraryA(name);
-}
-
-
-/*******************************************************************
- *         _local_unwind2  (CRTDLL.172)
- */
-void CDECL CRTDLL__local_unwind2( PEXCEPTION_FRAME endframe, DWORD nr )
-{
-        dprintf2(("CRTDLL: _local_unwind2\n"));
-}
-
-
-/*********************************************************************
- *                  _lrotl      (CRTDLL.175)
- */
-unsigned long CDECL CRTDLL__lrotl( unsigned long value, unsigned int shift )
-{
-  dprintf2(("CRTDLL: _lrotl\n"));
-  return (_lrotl(value, shift));
-}
-
-
-/*********************************************************************
- *                  _lrotr      (CRTDLL.176)
- */
-unsigned long CDECL CRTDLL__lrotr( unsigned long value, unsigned int shift )
-{
-  dprintf2(("CRTDLL: _lrotr\n"));
-  return (_lrotr(value, shift));
-}
-
-
-/*********************************************************************
- *                  _lseek      (CRTDLL.178)
- */
-long CDECL CRTDLL__lseek(int handle,long offset,int origin)
-{
-  dprintf2(("CRTDLL: _lssek\n"));
-  return (_lseek(handle, offset, origin));
-}
-
-
-/*********************************************************************
  *                  _ltoa       (CRTDLL.179)
  */
@@ -1380 +773 @@
 {
     return ltoa(x,buf,radix);
-}
-
-
-/*********************************************************************
- *                  _makepath   (CRTDLL.180)
- */
-void CDECL CRTDLL__makepath( char *path, char *drive,
-                    char *dir, char *fname, char *ext )
-{
-  dprintf2(("CRTDLL: _makepath\n"));
-  _makepath(path, drive, dir, fname, ext);
 }
 
@@ -1401 +783 @@
   dprintf2(("CRTDLL: _matherr\n"));
   return (_matherr(excep));
-}
-
-
-/*********************************************************************
- *                  _mkdir           (CRTDLL.232)
- */
-INT CDECL CRTDLL__mkdir(LPCSTR newdir)
-{
-        dprintf2(("CRTDLL: _mkdir\n"));
-        if (!CreateDirectoryA(newdir,NULL))
-                return -1;
-        return 0;
 }
 
@@ -1456 +826 @@
 
 /*********************************************************************
- *                  _msize        (CRTDLL.234)
- */
-size_t CDECL CRTDLL__msize( void *ptr )
-{
-  dprintf2(("CRTDLL: _msize\n"));
-  return (_msize(ptr));
-}
-
-
-/*********************************************************************
- *                  _onexit        (CRTDLL.236)
- */
-onexit_t CDECL CRTDLL__onexit(onexit_t t)
-{
-  dprintf2(("CRTDLL: _onexit\n"));
-  return (_onexit(t));
-}
-
-
-/*********************************************************************
- *                  _open        (CRTDLL.237)
- */
-HFILE CDECL CRTDLL__open(LPCSTR path,INT flags)
-{
-    dprintf2(("CRTDLL: _open\n"));
-    DWORD access = 0, creation = 0;
-    HFILE ret;
-    
-    switch(flags & 3)
-    {
-    case O_RDONLY: access |= GENERIC_READ; break;
-    case O_WRONLY: access |= GENERIC_WRITE; break;
-    case O_RDWR:   access |= GENERIC_WRITE | GENERIC_READ; break;
-    }
-
-    if (flags & 0x0100) /* O_CREAT */
-    {
-        if (flags & 0x0400) /* O_EXCL */
-            creation = CREATE_NEW;
-        else if (flags & 0x0200) /* O_TRUNC */
-            creation = CREATE_ALWAYS;
-        else
-            creation = OPEN_ALWAYS;
-    }
-    else  /* no O_CREAT */
-    {
-        if (flags & 0x0200) /* O_TRUNC */
-            creation = TRUNCATE_EXISTING;
-        else
-            creation = OPEN_EXISTING;
-    }
-    if (flags & 0x0008) /* O_APPEND */
-        dprintf2(("O_APPEND not supported\n" ));
-    if (flags & 0xf0f4) 
-      dprintf2(("CRTDLL_open file unsupported flags 0x%04x\n",flags));
-    /* End Fixme */
-
-    ret = CreateFileA( path, access, FILE_SHARE_READ | FILE_SHARE_WRITE,
-                         NULL, creation, FILE_ATTRIBUTE_NORMAL, -1 );
-    dprintf2(("CRTDLL_open file %s mode 0x%04x got handle %d\n", path,flags,ret));
-    return ret;
-}
-
-
-/*********************************************************************
- *                  _open_osfhandle  (CRTDLL.238)
- */
-INT CDECL CRTDLL__open_osfhandle( long osfhandle, int flags )
-{
-  dprintf2(("CRTDLL: _open_osfhandle\n"));
-HFILE handle;
- 
-        switch (osfhandle) {
-        case STD_INPUT_HANDLE :
-        case 0 :
-          handle=0;
-          break;
-        case STD_OUTPUT_HANDLE:
-        case 1:
-          handle=1;
-          break;
-        case STD_ERROR_HANDLE:
-        case 2:
-          handle=2;
-          break;
-        default:
-          return (-1);
-        }
-        dprintf2(("(handle %08lx,flags %d) return %d\n",
-                     osfhandle,flags,handle));
-        return handle;
-}
-
-
-/*********************************************************************
  *                  _purecall     (CRTDLL.249)
  */
@@ -1556 +831 @@
 {
   dprintf2(("CRTDLL: _purecall\n"));
-}
-
-
-/*********************************************************************
- *                  _putch     (CRTDLL.250)
- */
-INT CDECL CRTDLL__putch( int i )
-{
-  dprintf2(("CRTDLL: _putch\n"));
-  return (_putch(i));
 }
 
@@ -1590 +855 @@
 
 /*********************************************************************
- *                  _read     (CRTDLL.254)
- */
-INT CDECL CRTDLL__read(int handle, void *buf, size_t nbyte)
-{
-  dprintf(("CRTDLL: _read\n"));
-/*
-  int n, *pflags, *pla;
-  size_t j, k;
-  char *dst, c;
-
-  if ((pflags = _fd_flags (handle)) == NULL
-      || (pla = _fd_lookahead (handle)) == NULL)
-    {
-      errno = EBADF;
-      return -1;
-    }
-
-  *pflags &= ~F_CRLF;
-  if (nbyte > 0 && (*pflags & F_EOF))
-    return 0;
-  dst = buf;
-  n = read_lookahead (handle, dst, nbyte, pla);
-  if (n == -1)
-    return -1;
-  if ((*pflags & O_TEXT) && !(*pflags & F_TERMIO) && n > 0)
-    {
-      if (!(*pflags & (F_PIPE|F_SOCKET|F_DEV)) && dst[n-1] == 0x1a &&
-          _eof (handle))
-        {
-          --n;
-          *pflags |= F_EOF;
-          if (n == 0)
-            return 0;
-        }
-      if (n == 1 && dst[0] == '\r')
-        {
-          int saved_errno = errno;
-          j = read_lookahead (handle, &c, 1, pla);
-          if (j == -1 && errno == EAGAIN)
-            {
-              *pla = dst[0];
-              return -1;
-            }
-          errno = saved_errno;                
-          if (j == 1 && c == '\n')            
-            {
-              dst[0] = '\n';
-              *pflags |= F_CRLF;
-            }
-          else
-            *pla = c;
-        }
-      else
-        {
-
-          if (_crlf (dst, n, &k))
-            {
-
-              *pla = '\r';
-              --n;
-            }
-          if (k != n)
-            *pflags |= F_CRLF;
-          n = k;
-        }
-    }
-  return n;
-*/
-  return 0;
-}
-
-
-/*********************************************************************
- *                  _rmdir     (CRTDLL.255)
- */
-INT CDECL CRTDLL__rmdir(const char *path)
-{
-  dprintf2(("CRTDLL: _rmdir\n"));
-  if (!RemoveDirectoryA(path))
-        return -1;
-  return 0;
-}
-
-
-/*********************************************************************
  *                  _rmtmp     (CRTDLL.256)
  */
@@ -1681 +861 @@
   dprintf2(("CRTDLL: _rmtmp\n"));
   return(_rmtmp());
-}
-
-
-/*********************************************************************
- *           CRTDLL__rotl        (CRTDLL.257)
- */
-unsigned int CDECL CRTDLL__rotl( unsigned int value, unsigned int shift )
-{
-  dprintf2(("CRTDLL: _rotl\n"));
-  return (_rotl(value, shift));
-}
-
-
-/*********************************************************************
- *           CRTDLL__rotr        (CRTDLL.258)
- */
-unsigned int CDECL CRTDLL__rotr( unsigned int value, unsigned int shift )
-{
-  dprintf2(("CRTDLL: _rotr\n"));
-  return (_rotr(value, shift));
 }
 
@@ -1733 +893 @@
   dprintf2(("CRTDLL: _setjmp -> setjmp (NOT IDENTICAL!!!)\n"));
   return(setjmp( env));
-}
-
-
-/*********************************************************************
- *                  _setmode           (CRTDLL.263)
- */
-INT CDECL CRTDLL__setmode( INT fh,INT mode)
-{
-        dprintf2(("CRTDLL: _setmode\n"));
-        return (_setmode(fh, mode));
 }
 
@@ -1771 +921 @@
 
 /*********************************************************************
- *                  _sleep           (CRTDLL.265)
- */
-VOID CDECL CRTDLL__sleep(unsigned long timeout) 
-{
-  dprintf2(("_sleep for %ld milliseconds\n",timeout));
-  Sleep((timeout)?timeout:1);
-}
-
-
-/*********************************************************************
  *      _sopen                                  (CRTDLL.268)
  */
@@ -1841 +981 @@
 
 /*********************************************************************
- *           CRTDLL__spawnve     (CRTDLL.274)
- */
-int CDECL CRTDLL__spawnve( int i, char *s1, char ** s2, char ** s3 )
-{
-  dprintf2(("CRTDLL: _spawnve\n"));
-  return (_spawnve(i, s1, s2, s3));
-}
-
-
-/*********************************************************************
  *           CRTDLL__spawnvp     (CRTDLL.275)
  */
@@ -1870 +1000 @@
 
 /*********************************************************************
- *           _splitpath          (CRTDLL.277)
- */
-void CDECL CRTDLL__splitpath( char *path, char *drive, char *dir, char *fname, char *ext )
-{
-  dprintf2(("CRTDLL: _splitpath"));
-  _splitpath( path, drive, dir, fname, ext);
-}
-
-
-/*********************************************************************
- *           CRTDLL__stat        (CRTDLL.278)
- */
-int CDECL CRTDLL__stat( const char *s1, struct stat * n )
-{
-  dprintf2(("CRTDLL: _stat\n"));
-  return(_stat(s1, n));
-}
-
-
-/*********************************************************************
  *           CRTDLL__statusfp    (CRTDLL.279)
  */
@@ -1897 +1007 @@
   return (_status87());
 }
-
-
-/*********************************************************************
- *           CRTDLL__swab        (CRTDLL.299)
- */
-void CDECL CRTDLL__swab(char *s1, char *s2, int i)
-{
-  dprintf2(("CRTDLL: _swab\n"));
-  _swab(s1, s2, i);
-}
-
-
-/*********************************************************************
- *           CRTDLL__tell        (CRTDLL.302)
- */
-long CDECL CRTDLL__tell( int i )
-{
-  dprintf2(("CRTDLL: _tell\n"));
-  return (_tell(i));
-}
-
-
-/*********************************************************************
- *           CRTDLL__tempnam     (CRTDLL.303)
- */
-char * CDECL CRTDLL__tempnam( char *dir, char *prefix )
-{
-  dprintf2(("CRTDLL: _tempnam\n"));
-  return (_tempnam(dir, prefix));
-}
         
-
-/*********************************************************************
- *           CRTDLL__tolower     (CRTDLL.305)
- */
-int CDECL CRTDLL__tolower(int n)
-{
-  dprintf2(("CRTDLL: _tolower\n"));
-  return (_tolower(n));
-}
-
-
-/*********************************************************************
- *           CRTDLL__toupper     (CRTDLL.306)
- */
-int CDECL CRTDLL__toupper(int n)
-{
-  dprintf2(("CRTDLL: _toupper\n"));
-  return (_toupper(n));
-}
-
 
 /*********************************************************************
@@ -1960 +1020 @@
 
 /*********************************************************************
- *           CRTDLL__umask       (CRTDLL.310)
- */
-int CDECL CRTDLL__umask( int i )
-{
-  dprintf2(("CRTDLL: _umask\n"));
-  return (_umask(i));
-}
-
-
-/*********************************************************************
  *           CRTDLL__ungetch     (CRTDLL.311)
  */
@@ -1976 +1026 @@
   dprintf2(("CRTDLL: _ungetch\n"));
   return (_ungetch(i));
-}
-
-
-/*********************************************************************
- *                  _unlink           (CRTDLL.312)
- */
-INT CDECL CRTDLL__unlink(LPCSTR pathname)
-{
-    dprintf2(("CRTDLL: _unlink\n"));
-    int ret=0;
-    DOS_FULL_NAME full_name;
-
-    if (!DOSFS_GetFullName( pathname, FALSE, (CHAR*)&full_name )) {
-      dprintf2(("CRTDLL_unlink file %s bad name\n",pathname));
-      return EOF;
-    }
-  
-    ret=unlink(full_name.long_name);
-    dprintf2(("(%s unix %s)\n",
-                   pathname,full_name.long_name));
-    if(ret)
-      dprintf2((" Failed!\n"));
-
-    return ret;
-}
-
-
-/*********************************************************************
- *           _unloaddll  (CRTDLL.313)
- */
-int CDECL CRTDLL__unloaddll(void *handle)
-{
-  dprintf2(("CRTDLL: _unloaddll\n"));
-  return FreeLibrary((HMODULE)handle);
 }
 
@@ -2038 +1054 @@
 
 /*********************************************************************
- *                  _write        (CRTDLL.329)
- */
-INT CDECL CRTDLL__write(INT fd,LPCVOID buf,UINT count)
-{
-        dprintf2(("CRTDLL: _write\n"));
-        INT len=0;
-
-        if (fd == -1)
-          len = -1;
-        else if (fd<=2)
-          len = (UINT)write(fd,buf,(LONG)count);
-        else
-          len = _lwrite(fd,(LPCSTR)buf,count);
-        dprintf2(("%d/%d byte to dfh %d from %p,\n",
-                       len,count,fd,buf));
-        return len;
-}
-
-
-/*********************************************************************
  *                  _y0     (CRTDLL.332)
  */
@@ -2088 +1084 @@
 
 /*********************************************************************
- *                  abort       (CRTDLL.335)
- */
-void CDECL CRTDLL_abort( void )
-{
-  dprintf2(("CRTDLL: abort\n"));
-  abort();
-}
-
-
-/*********************************************************************
  *                  abs         (CRTDLL.336)
  */
@@ -2158 +1144 @@
   dprintf2(("CRTDLL: atan2\n"));
   return (atan2(y, x));
-}
-
-
-/*********************************************************************
- *                  atexit      (CRTDLL.342)
- */
-int CDECL CRTDLL_atexit(void (*func)(void))
-{
-  dprintf(("CRTDLL: atexit\n"));
-  if (_atexit_n >= sizeof (_atexit_v) / sizeof (_atexit_v[0]))
-    return -1;
-  _atexit_v[_atexit_n++] = func;
-  return 0;
 }
 
@@ -2237 +1210 @@
 
 /*********************************************************************
- *                  calloc      (CRTDLL.347)
- */
-void * CDECL CRTDLL_calloc( size_t n, size_t size )
-{
-//  dprintf2(("CRTDLL: calloc\n"));
-  return Heap_Alloc(size*n);
-}
-
-
-/*********************************************************************
  *                  ceil        (CRTDLL.348)
  */
@@ -2254 +1217 @@
            d));
   return (ceil(d));
-}
-
-
-/*********************************************************************
- *                  clearerr    (CRTDLL.349)
- */
-void CDECL CRTDLL_clearerr( FILE *fp )
-{
-  dprintf2(("CRTDLL: clearerr\n"));
-  clearerr(fp);
 }
 
@@ -2334 +1287 @@
 
 /*********************************************************************
- *                  exit          (CRTDLL.356)
- */
-void CDECL CRTDLL_exit(DWORD ret)
-{
-        dprintf2(("CRTDLL: exit\n"));
-        ExitProcess(ret);
-}
-
-
-/*********************************************************************
  *                  exp         (CRTDLL.357)
  */
@@ -2366 +1309 @@
 
 /*********************************************************************
- *                  fclose      (CRTDLL.359)
- */
-int CDECL CRTDLL_fclose( FILE *fp )
-{
-  dprintf2(("CRTDLL: fclose\n"));
-  return (fclose(fp));
-}
-
-
-/*********************************************************************
- *                  feof        (CRTDLL.360)
- */
-int CDECL CRTDLL_feof( FILE *fp )
-{
-  dprintf2(("CRTDLL: feof\n"));
-  return (feof(fp));
-}
-
-
-/*********************************************************************
- *                  ferror      (CRTDLL.361)
- */
-int CDECL CRTDLL_ferror( FILE *fp )
-{
-  dprintf2(("CRTDLL: ferror\n"));
-  return (ferror(fp));
-}
-
-
-/*********************************************************************
- *                  fflush      (CRTDLL.362)
- */
-int CDECL CRTDLL_fflush( FILE *fp )
-{
-  dprintf2(("CRTDLL: fflush\n"));
-  return (fflush(fp));
-}
-
-
-/*********************************************************************
- *                  fgetc       (CRTDLL.363)
- */
-int CDECL CRTDLL_fgetc( FILE *fp )
-{
-  dprintf2(("CRTDLL: fgetc\n"));
-  return (fgetc(fp));
-}
-
-
-/*********************************************************************
- *                  fgetpos     (CRTDLL.364)
- */
-int CDECL CRTDLL_fgetpos( FILE *fp, fpos_t *pos )
-{
-  dprintf2(("CRTDLL: fgetpos\n"));
-  return (fgetpos(fp, pos));
-}
-
-
-/*********************************************************************
- *                  fgets       (CRTDLL.365)
- */
-char * CDECL CRTDLL_fgets( char *s, int n, FILE *fp )
-{
-  dprintf2(("CRTDLL: fgets\n"));
-  return (fgets(s, n, fp));
-}
-
-
-/*********************************************************************
  *                  floor               (CRTDLL.367)
  */
@@ -2458 +1331 @@
 
 /*********************************************************************
- *                  fopen       (CRTDLL.369)
- */
-FILE * CDECL CRTDLL_fopen( const char *filename, const char *mode )
-{
-  dprintf2(("CRTDLL: fopen\n"));
-  return (fopen( filename, mode));
-}
-
-
-/*********************************************************************
- *                  fprintf       (CRTDLL.370)
- */
-INT CDECL CRTDLL_fprintf( FILE *file, LPSTR format, va_list arg )
-{
-    dprintf2(("CRTDLL: fprintf\n"));
-    return (fprintf(file, format, arg));
-}
-
-
-/*********************************************************************
- *                  fputc   (CRTDLL.371)
- */
-int CDECL CRTDLL_fputc( int c, FILE *fp )
-{
-  dprintf2(("CRTDLL: fputc\n"));
-  return (fputc(c, fp));
-}
-
-
-/*********************************************************************
- *                  fputs   (CRTDLL.372)
- */
-int CDECL CRTDLL_fputs( const char *s, FILE *fp )
-{
-  dprintf2(("CRTDLL: fputs\n"));
-  return (fputs(s, fp));
-}
-
-
-
-/*********************************************************************
- *                  fread  (CRTDLL.374)
- */
-size_t CDECL CRTDLL_fread( void *ptr, size_t size, size_t n, FILE *fp )
-{
-//  dprintf2(("CRTDLL: fread\n"));
-  return (fread(ptr, size, n, fp));
-}
-
- 
-/*********************************************************************
- *                  free          (CRTDLL.375)
- */
-VOID CDECL CRTDLL_free(LPVOID ptr)
-{
-//    dprintf2(("CRTDLL: free\n"));
-    Heap_Free(ptr);
-}
-
-
-/*********************************************************************
- *                  freopen       (CRTDLL.376)
- */
-FILE * CDECL CRTDLL_freopen( const char *filename, const char *mode, FILE *fp )
-{
-  dprintf2(("CRTDLL: freopen\n"));
-  return (freopen(filename, mode, fp));
-}
-
-
-/*********************************************************************
  *                  frexp         (CRTDLL.377)
  */
@@ -2539 +1341 @@
 
 /*********************************************************************
- *                  fscanf        (CRTDLL.378)
- */
-int CDECL CRTDLL_fscanf( FILE*fp, const char *format, va_list arg )
-{
-  dprintf2(("CRTDLL: fscanf\n"));
-  return (fscanf(fp, format, arg));
-}
-
-
-/*********************************************************************
- *                  fseek         (CRTDLL.379)
- */
-int CDECL CRTDLL_fseek( FILE *file, long int offset, int whence )
-{
-  dprintf2(("CRTDLL: fseek\n"));
-  return (fseek(file, offset, whence));
-}
-
-
-/*********************************************************************
- *                  fsetpos       (CRTDLL.380)
- */
-int CDECL CRTDLL_fsetpos( FILE *fp, const fpos_t *pos )
-{
-  dprintf2(("CRTDLL: fsetpos\n"));
-  return (fsetpos(fp, pos));
-}
-
-
-/*********************************************************************
- *                  ftell         (CRTDLL.381)
- */
-long int CDECL CRTDLL_ftell( FILE *fp )
-{
-  dprintf2(("CRTDLL: ftell\n"));
-  return (ftell(fp));
-}
-
-
-/*********************************************************************
- *                  fwrite     (CRTDLL.383)
- */
-DWORD CDECL CRTDLL_fwrite( LPVOID ptr, INT size, INT nmemb, FILE *file )
-{
-    dprintf2(("CRTDLL: fwrite\n"));
-    return (fwrite( ptr, size, nmemb, file));
-}
-
-
-/*********************************************************************
- *                  getc    (CRTDLL.385)
- */
-int CDECL CRTDLL_getc( FILE *fp )
-{
-  dprintf2(("CRTDLL: getc\n"));
-  return (getc(fp));
-}
-
-
-/*********************************************************************
- *                  getchar    (CRTDLL.386)
- */
-int CDECL CRTDLL_getchar( void )
-{
-  dprintf2(("CRTDLL: getchar\n"));
-  return (getchar());
-}
-
-
-/*********************************************************************
- *                  getenv    (CRTDLL.387)
- */
-char * CDECL CRTDLL_getenv( const char *name )
-{
-  dprintf2(("CRTDLL: getenv\n"));
-  return (getenv(name));
-}
-
-
-/*********************************************************************
- *                  gets    (CRTDLL.388)
- */
-char * CDECL CRTDLL_gets( char *s )
-{
-  dprintf2(("CRTDLL: gets\n"));
-  return (gets(s));
-}
-
-
-/*********************************************************************
  *                  gmtime    (CRTDLL.389)
  */
@@ -2831 +1543 @@
 
 /*********************************************************************
- *                  longjmp        (CRTDLL.423)
- */
-VOID CDECL CRTDLL_longjmp(jmp_buf env, int val)
-{
-    dprintf2(("CRTDLL: longjmp\n"));
-    longjmp(env, val);
-}
-
-
-/*********************************************************************
- *                  malloc        (CRTDLL.424)
- */
-VOID* CDECL CRTDLL_malloc(DWORD size)
-{
-//      dprintf2(("CRTDLL: malloc\n"));
-      return Heap_Alloc(size);
-}
-
-
-/*********************************************************************
  *                  mktime   (CRTDLL.433)
  */
@@ -2871 +1563 @@
 
 /*********************************************************************
- *                  perror   (CRTDLL.435)
- */
-void CDECL CRTDLL_perror( const char *s )
-{
-    dprintf2(("CRTDLL: perror\n"));
-    perror( s );
-}
-
-
-/*********************************************************************
  *                  pow      (CRTDLL.436)
  */
@@ -2897 +1579 @@
   dprintf2(("CRTDLL: printf\n"));
   return (printf(format, arg));
-}
-
-
-/*********************************************************************
- *                  putc      (CRTDLL.438)
- */
-int CDECL CRTDLL_putc( int c, FILE *fp )
-{
-    dprintf2(("CRTDLL: putc\n"));
-    return putc( c, fp );
-}
-
-
-/*********************************************************************
- *                  putchar      (CRTDLL.439)
- */
-int CDECL CRTDLL_putchar( int c )
-{
-    dprintf2(("CRTDLL: putchar\n"));
-    return putchar( c );
-}
-
-
-/*********************************************************************
- *                  puts         (CRTDLL.440)
- */
-int CDECL CRTDLL_puts( const char *s )
-{
-    dprintf2(("CRTDLL: puts\n"));
-    return puts( s );
 }
 
@@ -2953 +1605 @@
 
 /*********************************************************************
- *                  rand   (CRTDLL.443)
- */
-int CDECL CRTDLL_rand( void )
-{
-//    dprintf2(("CRTDLL: rand\n"));
-    return (rand());
-}
-
-
-/*********************************************************************
- *                  realloc   (CRTDLL.444)
- */
-void * CDECL CRTDLL_realloc( void *ptr, size_t size )
-{
-    dprintf2(("CRTDLL: realloc\n"));
-    return HeapReAlloc( GetProcessHeap(), 0, ptr, size );
-}
-
-
-/*********************************************************************
- *                  remove           (CRTDLL.445)
- */
-INT CDECL CRTDLL_remove(const char* file)
-{
-  dprintf2(("CRTDLL: remove\n"));
-  return (remove(file));
-}
-
-
-/*********************************************************************
- *                  rename      (CRTDLL.446)
- */
-int CDECL CRTDLL_rename (const char *old, const char *new2)
-{
-  dprintf2(("CRTDLL: rename\n"));
-  return (rename(old, new2));
-}
-
-
-/*********************************************************************
- *                  rewind      (CRTDLL.447)
- */
-void CDECL CRTDLL_rewind( FILE *fp )
-{
-  dprintf2(("CRTDLL: rewind\n"));
-  rewind(fp);
-}
-
-
-/*********************************************************************
  *      scanf                                   (CRTDLL.448)
  */
@@ -3013 +1615 @@
 
 /*********************************************************************
- *                  setbuf      (CRTDLL.449)
- */
-void CDECL CRTDLL_setbuf( FILE *fp, char *buf ) 
-{
-  dprintf2(("CRTDLL: setbuf\n"));
-  setbuf(fp, buf);
-}
-
-
-/*********************************************************************
- *                  setlocale      (CRTDLL.450)
- */
-char * CDECL CRTDLL_setlocale(int category,const char *locale)
-{
-  dprintf2(("CRTDLL: setlocale\n"));
-  return (setlocale(category, locale));
-}
-
-
-/*********************************************************************
  *                  setvbuf      (CRTDLL.451)
  */
@@ -3039 +1621 @@
   dprintf2(("CRTDLL: setvbuf\n"));
   return (setvbuf(fp, buf, mode, size));
-}
-
-
-/*********************************************************************
- *                  signal       (CRTDLL.452)
- */
-_SigFunc CDECL CRTDLL_signal(int sig, _SigFunc func)
-{
-  dprintf(("CRTDLL: signal\n"));
-  return (signal(sig, func));
 }
 
@@ -3127 +1699 @@
 
 /*********************************************************************
- *                  system         (CRTDLL.482)
- */
-int CDECL CRTDLL_system( const char *string )
-{
-  dprintf2(("CRTDLL: system\n"));
-  return system(string);
-}
-
-
-/*********************************************************************
  *                  tan           (CRTDLL.483)
  */
@@ -3178 +1740 @@
 }
 
-        
-/*********************************************************************
- *                  tmpnam           (CRTDLL.487)
- */
-char * CDECL CRTDLL_tmpnam( char *s )
-{
-  dprintf2(("CRTDLL: tmpnam\n"));
-  return (tmpnam(s));
-}
-
 
 /*********************************************************************
@@ -3224 +1776 @@
 
 /*********************************************************************
- *                  vfprintf       (CRTDLL.494)
- */
-INT CDECL CRTDLL_vfprintf( FILE *file, LPSTR format, va_list args )
-{
-    dprintf2(("CRTDLL: vfprintf\n"));
-    return (vfprintf(file, format, args));
-}
-
-
-/*********************************************************************
  *                  vprintf       (CRTDLL.496)
  */
@@ -3250 +1792 @@
   dprintf2(("CRTDLL: vsprintf(%08xh, %08xh)\n", s, format));
   return (vsprintf(s, format, arg));
-}
-
-
-/*********************************************************************
- *           CRTDLL__itow        (CRTDLL.600)
- */
-char * CDECL CRTDLL__itow(int i, char *s, int r)
-{
-  dprintf(("CRTDLL: _itow(%08xh, %08xh, %08xh) no unicode support !\n",
-           i,
-           s,
-           r));
-
-  return (itoa(i,s,r));
 }
 

trunk/src/crtdll/makefile

@@ -1 @@
-# $Id: makefile,v 1.12 2000-11-19 09:22:35 bird Exp $
+# $Id: makefile,v 1.13 2000-11-21 23:48:52 phaller Exp $
 
 #
@@ -18 +18 @@
 #
 OBJS = \
+$(OBJDIR)\crtdll_main.obj \
+$(OBJDIR)\dir.obj \
+$(OBJDIR)\exit.obj \
+$(OBJDIR)\file.obj \
+$(OBJDIR)\mbstring.obj \
+$(OBJDIR)\memory.obj \
+$(OBJDIR)\spawn.obj \
+                     \
 $(OBJDIR)\crtdll.obj \
 $(OBJDIR)\asmhlp.obj \
@@ -24 +32 @@
 $(OBJDIR)\crt_string.obj \
 $(OBJDIR)\crt_memory.obj \
-$(OBJDIR)\crt_mb.obj \
 $(OBJDIR)\crt_wc.obj \
 $(OBJDIR)\initterm.obj \
@@ -52 +59 @@
 #
 !include $(PDWIN32_INCLUDE)/pdwin32.post
-

trunk/src/crtdll/stubs.cpp

@@ -1 @@
-/* $Id: stubs.cpp,v 1.3 2000-02-21 23:11:31 sandervl Exp $ */
+/* $Id: stubs.cpp,v 1.4 2000-11-21 23:48:53 phaller Exp $ */
 
 /*
@@ -26 +26 @@
 
 /*********************************************************************
- *      __dllonexit                             (CRTDLL.25)
- */
-VOID CDECL CRTDLL___dllonexit ()
-{       
-  dprintf(("__dllonexit not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-}
-
-
-/*********************************************************************
  *                  __fpecode            (CRTDLL.27)
  */
@@ -58 +48 @@
 
 /*********************************************************************
- *      _abnormal_termination                   (CRTDLL.36)
- */
-int CDECL CRTDLL__abnormal_termination(void)
-{
-  dprintf(("CRTDLL: _abnormal_termination  not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
-
-
-/*********************************************************************
- *           _chgsign    (CRTDLL.53)
- */
-double CDECL CRTDLL__chgsign(double x)
-{
-  dprintf(("CRTDLL: _chgsign not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
-
-
-/*********************************************************************
- *                  _commit    (CRTDLL.58)
- */
-int CDECL CRTDLL__commit( int fd )
-{
-  dprintf(("CRTDLL: _commit not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
-
-
-/*********************************************************************
- *                  _copysign    (CRTDLL.62)
- */
-double CDECL CRTDLL__copysign( double d, double s )
-{
-  dprintf(("CRTDLL: _copysign not implemented\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
-
-
-/*********************************************************************
- *      _expand                                 (CRTDLL.88)
- */
-void * CDECL CRTDLL__expand( void *ptr, size_t size )
-{
-  dprintf(("CRTDLL: _expand not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
-
-
-/*********************************************************************
- *      _filbuf                                 (CRTDLL.94)
- */
-int CDECL CRTDLL__filbuf(FILE * f)
-{
-  dprintf(("CRTDLL: _filbuf not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
-
-
-/*********************************************************************
-*                  _findclose    (CRTDLL.098)
-*/
-int CDECL CRTDLL__findclose( long handle )
-{
-  dprintf(("CRTDLL: _findclose not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
-
-
-/*********************************************************************
- *      _findfirst                              (CRTDLL.099)
- */
-DWORD CDECL CRTDLL__findfirst(const char *_name, struct _finddata_t *result)
-{
-  dprintf(("CRTDLL: _findfirst not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
-
-
-/*********************************************************************
- *      _findnext                               (CRTDLL.100)
- */
-INT CDECL CRTDLL__findnext(DWORD hand, struct find_t * x2)
-{
-  dprintf(("CRTDLL: _findnext not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
-
-
-/*********************************************************************
- *                  _finite     (CRTDLL.101)
- */
-INT CDECL CRTDLL__finite(double x)
-{
-  dprintf(("CRTDLL: _finite not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
-
-
-/*********************************************************************
- *      _flsbuf                                 (CRTDLL.102)
- */
-INT CDECL CRTDLL__flsbuf(int i, FILE * f)
-{
-  dprintf(("CRTDLL: _flsbuf not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
-
-
-/*********************************************************************
  *                  _fpclass     (CRTDLL.105)
  */
@@ -212 +81 @@
 
 /*********************************************************************
- *      _fsopen                                 (CRTDLL.110)
- */
-FILE * CDECL CRTDLL__fsopen( const char *file, const char *mode, int shflag )
-{
-  dprintf(("CRTDLL: _fsopen not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
-
-
-/*********************************************************************
  *      _futime                                 (CRTDLL.115)
  */
@@ -234 +92 @@
 
 /*********************************************************************
- *                  _get_osfhandle     (CRTDLL.117)
- */
-void* CDECL CRTDLL__get_osfhandle( int fileno )
-{
-  dprintf(("CRTDLL: _get_osfhandle not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return 0;
-}
-
-
-/*********************************************************************
- *                  _getdiskfree     (CRTDLL.122)
- */
-unsigned int CDECL CRTDLL__getdiskfree( unsigned int drive, struct _diskfree_t *diskspace)
-{
-  dprintf(("CRTDLL: _getdiskfree not implemented\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return 0;
-}
-
-
-/*********************************************************************
  *                  _getdllprocaddr     (CRTDLL.123)
  */
@@ -267 +103 @@
 
 /*********************************************************************
- *      _heapwalk                               (CRTDLL.133)
- */
-int CDECL CRTDLL__heapwalk( struct _heapinfo *entry )
-{
-  dprintf(("CRTDLL: _heapwalk not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return 0;
-}
-
-
-/*********************************************************************
- *                  _isatty       (CRTDLL.137)
- */
-BOOL CDECL CRTDLL__isatty(DWORD x)
-{
-   dprintf(("CRTDLL: _isatty(%ld) not implemented.\n",x));
-   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-   return TRUE;
-}
-
-
-/*********************************************************************
  *                  _ismbbalnum     (CRTDLL.139)
  */
@@ -560 +374 @@
   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
   return 0;
-}
-
-
-/*********************************************************************
- *                  _isnan     (CRTDLL.164)
- */
-int CDECL CRTDLL__isnan( double x )
-{
-  dprintf(("CRTDLL: _isnan not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
 }
 
@@ -609 +412 @@
 
 /*********************************************************************
- *      _lsearch                                (CRTDLL.177)
- */
-void * CDECL CRTDLL__lsearch(const void *key, void *base, size_t *nelp, size_t width,
-         int (*compar)(const void *, const void *))
-{
-  dprintf(("CRTDLL: _lsearch not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
-
-
-/*********************************************************************
  *                  _mbbtombc        (CRTDLL.182)
  */
@@ -639 +430 @@
   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
   return FALSE;
-}
-
-
-/*********************************************************************
- *                  _mbccpy        (CRTDLL.184)
- */
-void CDECL CRTDLL__mbccpy( unsigned char *dst, const unsigned char *src )
-{
-  dprintf(("CRTDLL: _mbccpy not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 }