Create a branch for cmake bringup.

svn path=/branches/cmake-bringup/; revision=48236

lib/sdk/crt/stdio/access.c

@@ -0,0 +1,36 @@
+#include <precomp.h>
+#include <tchar.h>
+
+#ifdef _UNICODE
+ #define _TS S
+ #define sT "S"
+#else
+ #define _TS s
+ #define sT "s"
+#endif
+
+#define MK_STR(s) #s
+
+/*
+ * INTERNAL
+ */
+int access_dirT(const _TCHAR *_path)
+{
+    DWORD Attributes = GetFileAttributes(_path);
+    TRACE(MK_STR(is_dirT)"('%"sT"')\n", _path);
+
+    if (Attributes == (DWORD)-1) {
+         _dosmaperr(GetLastError());
+        return -1;
+    }
+
+    if ((Attributes & FILE_ATTRIBUTE_DIRECTORY) != FILE_ATTRIBUTE_DIRECTORY)
+    {
+      __set_errno(EACCES);
+      return -1;
+    }
+
+   return 0;
+}
+
+

lib/sdk/crt/stdio/find.c

@@ -0,0 +1,19 @@
+#include <precomp.h>
+#include <tchar.h>
+#include <io.h>
+
+// Generate _findfirst and _findnext
+#include "findgen.c"
+
+/*
+ * @implemented
+ */
+int _findclose(intptr_t handle)
+{
+  if (!FindClose((HANDLE)handle)) {
+    _dosmaperr(GetLastError());
+    return -1;
+  }
+
+  return 0;
+}

lib/sdk/crt/stdio/find64.c

@@ -0,0 +1,13 @@
+#include <precomp.h>
+#include <tchar.h>
+#include <io.h>
+
+// Generate _findfirst64 and _findnext64
+#undef _findfirst
+#define _findfirst _findfirst64
+#undef _findnext
+#define _findnext _findnext64
+#undef _finddata_t
+#define _finddata_t __finddata64_t
+
+#include "findgen.c"

lib/sdk/crt/stdio/findgen.c

@@ -0,0 +1,46 @@
+
+/*
+ * @implemented
+ */
+intptr_t _tfindfirst(const _TCHAR* _name, struct _tfinddata_t* result)
+{
+    WIN32_FIND_DATA FindFileData;
+    HANDLE hFindFile;
+
+    hFindFile = FindFirstFile(_name, &FindFileData);
+    if (hFindFile == INVALID_HANDLE_VALUE) {
+        _dosmaperr(GetLastError());
+        return -1;
+    }
+
+    result->attrib = FindFileData.dwFileAttributes;
+    result->time_create = FileTimeToUnixTime(&FindFileData.ftCreationTime,NULL);
+    result->time_access = FileTimeToUnixTime(&FindFileData.ftLastAccessTime,NULL);
+    result->time_write = FileTimeToUnixTime(&FindFileData.ftLastWriteTime,NULL);
+    result->size = (((__int64)FindFileData.nFileSizeHigh)<<32) + FindFileData.nFileSizeLow;
+    _tcsncpy(result->name,FindFileData.cFileName,MAX_PATH);
+
+    return (intptr_t)hFindFile;
+}
+
+/*
+ * @implemented
+ */
+int _tfindnext(intptr_t handle, struct _tfinddata_t* result)
+{
+    WIN32_FIND_DATA FindFileData;
+
+    if (!FindNextFile((HANDLE)handle, &FindFileData)) {
+    	_dosmaperr(GetLastError());
+        return -1;
+	}
+
+    result->attrib = FindFileData.dwFileAttributes;
+    result->time_create = FileTimeToUnixTime(&FindFileData.ftCreationTime,NULL);
+    result->time_access = FileTimeToUnixTime(&FindFileData.ftLastAccessTime,NULL);
+    result->time_write = FileTimeToUnixTime(&FindFileData.ftLastWriteTime,NULL);
+    result->size = (((__int64)FindFileData.nFileSizeHigh)<<32) + FindFileData.nFileSizeLow;
+    _tcsncpy(result->name,FindFileData.cFileName, MAX_PATH);
+
+    return 0;
+}

lib/sdk/crt/stdio/findi64.c

@@ -0,0 +1,13 @@
+#include <precomp.h>
+#include <tchar.h>
+#include <io.h>
+
+// Generate _findfirsti64 and _findnexti64
+#undef _findfirst
+#define _findfirst _findfirsti64
+#undef _findnext
+#define _findnext _findnexti64
+#undef _finddata_t
+#define _finddata_t _finddatai64_t
+
+#include "findgen.c"

lib/sdk/crt/stdio/fmode.c

@@ -0,0 +1,12 @@
+/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
+#include <precomp.h>
+
+int _fmode = _O_TEXT;
+
+/*
+ * @implemented
+ */
+int *__p__fmode(void)
+{
+   return &_fmode;
+}

lib/sdk/crt/stdio/lnx_sprintf.c

@@ -0,0 +1,881 @@
+/*
+ * COPYRIGHT:        See COPYING in the top level directory
+ * PURPOSE:          CRT's vsnprintf
+ * FILE:             lib/sdk/crt/stdio/lnx_printf.c
+ * PROGRAMERS:       David Welch
+                     Eric Kohl
+                     Gregor Schneider
+ * TODO:
+ *   - Verify the implementation of '%Z'.
+ */
+
+/* 
+ *  Parts from linux/lib/vsprintf.c
+ *  Lars Wirzenius & Linus Torvalds
+ *  Wirzenius wrote this portably, Torvalds fucked it up :-)
+ */
+
+#include <precomp.h>
+
+#include <wchar.h>
+#include <tchar.h>
+
+#define ZEROPAD     1  /* pad with zero */
+#define SIGN        2  /* unsigned/signed */
+#define PLUS        4  /* show plus */
+#define SPACE       8  /* space if plus */
+#define LEFT       16  /* left justified */
+#define SPECIAL    32  /* 0x */
+#define LARGE      64  /* use 'ABCDEF' instead of 'abcdef' */
+#define ZEROTRUNC 128  /* truncate zero's */
+#define REMOVEHEX 256  /* remove 0x from BASE 16 */
+
+static
+__inline
+int
+do_div(long long *n, int base)
+{
+  int a;
+  a = ((unsigned long long) *n) % (unsigned) base;
+  *n = ((unsigned long long) *n) / (unsigned) base;
+  return a;
+}
+
+
+static int skip_atoi(const char **s)
+{
+  int i=0;
+
+  while (isdigit(**s))
+    i = i*10 + *((*s)++) - '0';
+  return i;
+}
+
+
+static char *
+number(char * buf, char * end, long long num, int base, int size, int precision, int type)
+{
+  char c,sign,tmp[66];
+  const char *digits;
+  const char *small_digits = "0123456789abcdefghijklmnopqrstuvwxyz";
+  const char *large_digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  int i;
+
+  digits = (type & LARGE) ? large_digits : small_digits;
+  if (type & LEFT)
+    type &= ~ZEROPAD;
+  if (base < 2 || base > 36)
+    return 0;
+  c = (type & ZEROPAD) ? '0' : ' ';
+  sign = 0;
+  if (type & SIGN) {
+    if (num < 0) {
+      sign = '-';
+      num = -num;
+      size--;
+    } else if (type & PLUS) {
+      sign = '+';
+      size--;
+    } else if (type & SPACE) {
+      sign = ' ';
+      size--;
+    }
+  }
+
+  if ((type & SPECIAL) && ((type & REMOVEHEX) == 0)) {
+    if (base == 16)
+      size -= 2;
+  }
+  i = 0;
+  if ((num == 0) && (precision !=0))
+    tmp[i++] = '0';
+  else while (num != 0)
+    tmp[i++] = digits[do_div(&num,base)];
+  if (i > precision)
+    precision = i;
+  size -= precision;
+  if (!(type&(ZEROPAD+LEFT))) {
+    while(size-->0) {
+      if (buf <= end)
+        *buf = ' ';
+      ++buf;
+    }
+  }
+  if (sign) {
+    if (buf <= end)
+      *buf = sign;
+    ++buf;
+  }
+
+  if ((type & SPECIAL) && ((type & REMOVEHEX) == 0)) {
+    if (base==16) {
+      if (buf <= end)
+        *buf = '0';
+      ++buf;
+      if (buf <= end)
+        *buf = digits[33];
+      ++buf;
+    }
+  }
+
+  if (!(type & LEFT)) {
+    while (size-- > 0) {
+      if (buf <= end)
+        *buf = c;
+      ++buf;
+    }
+  }
+  while (i < precision--) {
+    if (buf <= end)
+      *buf = '0';
+    ++buf;
+  }
+  while (i-- > 0) {
+    if (buf <= end)
+      *buf = tmp[i];
+    ++buf;
+  }
+  while (size-- > 0) {
+    if (buf <= end)
+      *buf = ' ';
+    ++buf;
+  }
+
+  return buf;
+}
+
+typedef struct {
+  unsigned int mantissal:32;
+  unsigned int mantissah:20;
+  unsigned int exponent:11;
+  unsigned int sign:1;
+} ieee_double_t;
+
+static __inline void fracrnd(double *number, int prec)
+{
+  /* Shifts fractional digits to decimal places and compares to round table */
+  /* Only suitable to determine the exponent with more precision, not for normal rounding */
+  /* Incoming numbers are expected to range from approx -10.0 to 10.0 */
+  int lpos = 1, ubound, sign = 1;
+  long decimal = abs((long)*number);
+  double frac = (*number - decimal) * 10;
+  long rt[] = 
+  {
+    0,
+    9,
+    99,
+    999,
+    9999,
+    99999,
+    999999,
+    9999999,
+    99999999,
+    999999999
+  };
+
+  if (*number < 0) 
+  {
+    sign = -1;
+  }
+  ubound = min(prec, sizeof(rt)/sizeof(*rt) - 1);
+  while ((long)frac % 10 != 0 && lpos < ubound)
+  {
+    frac *= 10;
+    lpos++;
+  }
+  if (abs((long)frac) == rt[lpos])
+  {
+    *number = sign * (decimal + 1);
+  }
+}
+
+static char *
+numberf(char * buf, char * end, double num, char exp_sign, int size, int precision, int type)
+{
+  double exponent = 0.0;
+  double e = 0.0;
+  long ie;
+
+  int i = 0;
+  int j = 0;
+  int ro = 0;
+  int isize;
+
+  double num2, frac, intr;
+  double p;
+
+  char c, sign, digits[66];
+  char *tmp;
+
+  union
+  {
+    double*  __n;
+    ieee_double_t*  n;
+  } n;
+
+  n.__n = &num;
+
+  if ( exp_sign == 'g' || exp_sign == 'G' || exp_sign == 'e' || exp_sign == 'E' )
+  {
+    ie = ((unsigned int)n.n->exponent - (unsigned int)0x3ff);
+    if (num != 0.0)
+    {
+      exponent = ie/3.321928;
+    }
+  }
+
+  if ( exp_sign == 'g' || exp_sign == 'G' )
+  {
+    type |= ZEROTRUNC;
+    if ( exponent < -4 || fabs(exponent) >= precision )
+      exp_sign -= 2; // g -> e and G -> E
+    else
+      exp_sign = 'f';
+    if (type & SPECIAL) precision--;
+  }
+
+  if ( exp_sign == 'e' ||  exp_sign == 'E' )
+  {
+    if (num != 0.0)
+    {
+      /* Find a suitable exponent */
+      frac = modf(exponent, &e);
+      num2 = num/pow(10.0L, (long double)e);
+      /* Check if rounding is possible */
+      fracrnd(&num2, precision);
+      if (num2 < 1.0 && num2 > -1.0)
+      {
+        e--;
+      }
+      else if (num2 <= -10.0 || num2 >= 10.0)
+      {
+        e++;
+      }
+    }
+
+    /* size-5 because "e+abc" is going to follow */
+    buf = numberf(buf, end, num/pow(10.0L,(long double)e), 'f', size-5, precision, type);
+    isize = 4;
+    while(*(buf-1) == ' ')
+    {
+      isize++;
+      --buf;
+    }
+
+    if (buf <= end)
+      *buf = exp_sign;
+    ++buf;
+    size--;
+
+    ie = (long)e;
+    type = LEFT | SIGN | PLUS;
+    buf = number(buf, end, ie, 10, isize, 3, type);
+    return buf;
+  }
+
+  if ( exp_sign == 'f' )
+  {
+    if (type & LEFT)
+      type &= ~ZEROPAD;
+
+    c = (type & ZEROPAD) ? '0' : ' ';
+    sign = 0;
+
+    if (num < 0)
+    {
+      sign = '-';
+      num = fabs(num);
+      size--;
+    }
+    else if (type & PLUS)
+    {
+      sign = '+';
+      size--;
+    }
+    else if (type & SPACE)
+    {
+      sign = ' ';
+      size--;
+    }
+
+    frac = modf(num,&intr);
+
+    // # flags forces a . and prevents truncation of trailing zero's
+    if ( precision > 0 )
+    {
+      i = precision-1;
+      while ( i >= 0  )
+      {
+        frac*=10.0L;
+        frac = modf(frac, &p);
+        digits[i] = (int)p + '0';
+        i--;
+      }
+
+      i = precision;
+      size -= precision;
+    } 
+
+    if ( precision >= 1 || type & SPECIAL)
+    {
+      digits[i++] = '.';
+      size--;
+    }
+
+    ro = 0;
+    if ( frac > 0.5 )
+    {
+      ro = 1;
+    }
+
+    if ( intr == 0.0 )
+    {
+      digits[i++] = '0';
+      size--;
+    }
+    else
+    {
+      while ( intr > 0.0 )
+      {
+        p = intr;
+        intr/=10.0L;
+        modf(intr, &intr);
+
+        p -= 10.0*intr;
+
+        digits[i++] = (int)p + '0';
+        size--;
+      }
+    }
+
+    j = 0;
+    while ( j < i && ro == 1)
+    {
+      if ( digits[j] >= '0' && digits[j] <= '8' )
+      {
+        digits[j]++;
+        ro = 0;
+      }
+      else if ( digits[j] == '9' )
+      {
+        digits[j] = '0';
+      }
+      j++;
+    }
+    if ( ro == 1 )
+      digits[i++] = '1';
+
+    digits[i] = 0;
+
+    if (!(type & (ZEROPAD+LEFT)))
+    {
+      while(size-->0)
+      {
+        if (buf <= end)
+          *buf = ' ';
+        ++buf;
+      }
+    }
+    if (sign)
+    {
+      if (buf <= end)
+        *buf = sign;
+      ++buf;
+    }
+
+    if (!(type & (ZEROPAD+LEFT)))
+    {
+      while(size-->0)
+      {
+        if (buf <= end)
+          *buf = ' ';
+        ++buf;
+      }
+    }
+
+    if (!(type & LEFT))
+    {
+      while (size-- > 0)
+      {
+        if (buf <= end)
+          *buf = c;
+        ++buf;
+      }
+    }
+
+    tmp = digits;
+    if ( type & ZEROTRUNC && ((type & SPECIAL) != SPECIAL) )
+    {
+      j = 0;
+      while ( j < i && ( *tmp == '0' || *tmp == '.' ))
+      {
+        tmp++;
+        i--;
+      }
+    }
+    while (i-- > 0)
+    {
+      if (buf <= end)
+        *buf = tmp[i];
+      ++buf;
+    }
+    while (size-- > 0)
+    {
+      if (buf <= end)
+        *buf = ' ';
+      buf++;
+    }
+  }
+  return buf;
+}
+
+static char*
+string(char* buf, char* end, const char* s, int len, int field_width, int precision, int flags)
+{
+  int i;
+  char c;
+
+  c = (flags & ZEROPAD) ? '0' : ' ';
+
+  if (s == NULL)
+  {
+    s = "<NULL>";
+    len = 6;
+  }
+  else
+  {
+    if (len == -1)
+    {
+      len = 0;
+      while ((unsigned int)len < (unsigned int)precision && s[len])
+        len++;
+    }
+    else
+    {
+      if ((unsigned int)len > (unsigned int)precision)
+        len = precision;
+    }
+  }
+  if (!(flags & LEFT))
+    while (len < field_width--)
+    {
+      if (buf <= end)
+        *buf = c;
+      ++buf;
+    }
+  for (i = 0; i < len; ++i)
+  {
+    if (buf <= end)
+      *buf = *s++;
+    ++buf;
+  }
+  while (len < field_width--)
+  {
+    if (buf <= end)
+      *buf = ' ';
+    ++buf;
+  }
+  return buf;
+}
+
+static char*
+stringw(char* buf, char* end, const wchar_t* sw, int len, int field_width, int precision, int flags)
+{
+  int i;
+  char c;
+
+  c = (flags & ZEROPAD) ? '0' : ' ';
+
+  if (sw == NULL)
+  {
+    sw = L"<NULL>";
+    len = 6;
+  }
+  else
+  {
+    if (len == -1)
+    {
+      len = 0;
+      while ((unsigned int)len < (unsigned int)precision && sw[len])
+        len++;
+    }
+    else
+    {
+      if ((unsigned int)len > (unsigned int)precision)
+        len = precision;
+    }
+  }
+  if (!(flags & LEFT))
+    while (len < field_width--)
+    {
+      if (buf <= end)
+        *buf = c;
+      buf++;
+    }
+  for (i = 0; i < len; ++i)
+  {
+    if (buf <= end)
+      *buf = (unsigned char)(*sw++);
+    buf++;
+  }
+  while (len < field_width--)
+  {
+    if (buf <= end)
+      *buf = ' ';
+    buf++;
+  }
+  return buf;
+}
+
+/*
+ * @implemented
+ */
+int __cdecl lnx_vsnprintf(char *buf, size_t cnt, const char *fmt, va_list args)
+{
+  int len;
+  unsigned long long num;
+  double _double;
+
+  int base;
+  char *str, *end;
+  const char *s;
+  const wchar_t *sw;
+
+  int flags;  /* flags to number() */
+
+  int field_width;  /* width of output field */
+  int precision;    /* min. # of digits for integers; max
+                    number of chars for from string */
+  int qualifier;    /* 'h', 'l', 'L', 'I' or 'w' for integer fields */
+
+  str = buf;
+  end = buf + cnt - 1;
+  if (end < buf - 1) {
+    end = ((char *) -1);
+    cnt = end - buf + 1;
+  }
+
+  for ( ; *fmt ; ++fmt) {
+    if (*fmt != '%') {
+      if (str <= end)
+        *str = *fmt;
+      ++str;
+      continue;
+    }
+
+    /* process flags */
+    flags = 0;
+repeat:
+    ++fmt;  /* this also skips first '%' */
+    switch (*fmt) {
+        case '-': flags |= LEFT; goto repeat;
+        case '+': flags |= PLUS; goto repeat;
+        case ' ': flags |= SPACE; goto repeat;
+        case '#': flags |= SPECIAL; goto repeat;
+        case '0': flags |= ZEROPAD; goto repeat;
+    }
+
+    /* get field width */
+    field_width = -1;
+    if (isdigit(*fmt))
+      field_width = skip_atoi(&fmt);
+    else if (*fmt == '*') {
+      ++fmt;
+      /* it's the next argument */
+      field_width = va_arg(args, int);
+      if (field_width < 0) {
+        field_width = -field_width;
+        flags |= LEFT;
+      }
+    }
+
+    /* get the precision */
+    precision = -1;
+    if (*fmt == '.') {
+      ++fmt;
+      if (isdigit(*fmt))
+        precision = skip_atoi(&fmt);
+      else if (*fmt == '*') {
+        ++fmt;
+        /* it's the next argument */
+        precision = va_arg(args, int);
+      }
+      if (precision < 0)
+        precision = 0;
+    }
+
+    /* get the conversion qualifier */
+    qualifier = -1;
+    if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || *fmt == 'w') {
+      qualifier = *fmt;
+      ++fmt;
+    } else if (*fmt == 'I' && *(fmt+1) == '6' && *(fmt+2) == '4') {
+      qualifier = *fmt;
+      fmt += 3;
+    } else if (*fmt == 'I' && *(fmt+1) == '3' && *(fmt+2) == '2') {
+      qualifier = 'l';
+      fmt += 3;
+    } else if (*fmt == 'F' && *(fmt+1) == 'p') {
+      fmt += 1;
+      flags |= REMOVEHEX;
+    }
+
+    /* default base */
+    base = 10;
+
+    switch (*fmt) {
+      case 'c': /* finished */
+        if (qualifier == 'l' || qualifier == 'w') {
+          wchar_t sw1[2];
+          /* print unicode string */
+          sw1[0] = (wchar_t) va_arg(args, int);
+          sw1[1] = 0;
+          str = stringw(str, end, (wchar_t *)&sw1, -1, field_width, precision, flags);
+        } else {
+          char s1[2];
+          /* print ascii string */
+          s1[0] = ( unsigned char) va_arg(args, int);
+          s1[1] = 0;
+          str = string(str, end, (char *)&s1, -1,  field_width, precision, flags);
+        }
+        continue;
+
+      case 'C': /* finished */
+        if (!(flags & LEFT))
+          while (--field_width > 0) {
+            if (str <= end)
+              *str = ' ';
+            ++str;
+          }
+          if (qualifier == 'h') {
+            if (str <= end)
+              *str = (unsigned char) va_arg(args, int);
+            ++str;
+          } else {
+            if (str <= end)
+              *str = (unsigned char)(wchar_t) va_arg(args, int);
+            ++str;
+          }
+          while (--field_width > 0) {
+            if (str <= end)
+              *str = ' ';
+            ++str;
+          }
+          continue;
+
+      case 's': /* finished */
+        if (qualifier == 'l' || qualifier == 'w') {
+          /* print unicode string */
+          sw = va_arg(args, wchar_t *);
+          str = stringw(str, end, sw, -1, field_width, precision, flags);
+        } else {
+          /* print ascii string */
+          s = va_arg(args, char *);
+          str = string(str, end, s, -1,  field_width, precision, flags);
+        }
+        continue;
+
+      case 'S':
+        if (qualifier == 'h') {
+          /* print ascii string */
+          s = va_arg(args, char *);
+          str = string(str, end, s, -1,  field_width, precision, flags);
+        } else {
+          /* print unicode string */
+          sw = va_arg(args, wchar_t *);
+          str = stringw(str, end, sw, -1, field_width, precision, flags);
+        }
+        continue;
+
+      case 'Z':
+        if (qualifier == 'w') {
+          /* print counted unicode string */
+          PUNICODE_STRING pus = va_arg(args, PUNICODE_STRING);
+          if ((pus == NULL) || (pus->Buffer == NULL)) {
+            sw = NULL;
+            len = -1;
+          } else {
+            sw = pus->Buffer;
+            len = pus->Length / sizeof(WCHAR);
+          }
+          str = stringw(str, end, sw, len,  field_width, precision, flags);
+        } else {
+          /* print counted ascii string */
+          PANSI_STRING pus = va_arg(args, PANSI_STRING);
+          if ((pus == NULL) || (pus->Buffer == NULL)) {
+            s = NULL;
+            len = -1;
+          } else {
+            s = pus->Buffer;
+            len = pus->Length;
+          }
+          str = string(str, end, s, len,  field_width, precision, flags);
+        }
+        continue;
+
+      case 'p':
+        if ((flags & LARGE) == 0)
+            flags |= LARGE;
+
+        if (field_width == -1) {
+          field_width = 2 * sizeof(void *);
+          flags |= ZEROPAD;
+        }
+        str = number(str, end,
+          (uintptr_t) va_arg(args, void *), 16,
+          field_width, precision, flags);
+        continue;
+
+      case 'n':
+        /* FIXME: What does C99 say about the overflow case here? */
+        if (qualifier == 'l') {
+          long * ip = va_arg(args, long *);
+          *ip = (str - buf);
+        } else {
+          int * ip = va_arg(args, int *);
+          *ip = (str - buf);
+        }
+        continue;
+
+      /* float number formats - set up the flags and "break" */
+      case 'e':
+      case 'E':
+      case 'f':
+      case 'g':
+      case 'G':
+        _double = (double)va_arg(args, double);
+        if ( _isnan(_double) ) {
+          s = "Nan";
+          len = 3;
+          while ( len > 0 ) {
+             if (str <= end)
+               *str = *s++;
+             ++str;
+             len --;
+          }
+       } else if ( _isinf(_double) < 0 ) {
+          s = "-Inf";
+          len = 4;
+          while ( len > 0 ) {
+             if (str <= end)
+                *str = *s++;
+              ++str;
+             len --;
+          }
+       } else if ( _isinf(_double) > 0 ) {
+          s = "+Inf";
+          len = 4;
+          while ( len > 0 ) {
+             if (str <= end)
+               *str = *s++;
+             ++str;
+             len --;
+          }
+       } else {
+          if ( precision == -1 )
+             precision = 6;
+             str = numberf(str, end, _double, *fmt, field_width, precision, flags);
+       }
+        continue;
+
+      /* integer number formats - set up the flags and "break" */
+      case 'o':
+        base = 8;
+        break;
+
+      case 'b':
+        base = 2;
+        break;
+
+      case 'X':
+        flags |= LARGE;
+      case 'x':
+        base = 16;
+        break;
+
+      case 'd':
+      case 'i':
+        flags |= SIGN;
+      case 'u':
+        break;
+
+      default:
+        if (*fmt) {
+          if (str <= end)
+            *str = *fmt;
+          ++str;
+        } else
+          --fmt;
+        continue;
+    }
+
+    if (qualifier == 'I')
+      num = va_arg(args, unsigned long long);
+    else if (qualifier == 'l') {
+      if (flags & SIGN)
+        num = va_arg(args, long);
+      else
+        num = va_arg(args, unsigned long);
+    }
+    else if (qualifier == 'h') {
+      if (flags & SIGN)
+        num = va_arg(args, int);
+      else
+        num = va_arg(args, unsigned int);
+    }
+    else {
+      if (flags & SIGN)
+        num = va_arg(args, int);
+      else
+        num = va_arg(args, unsigned int);
+    }
+    str = number(str, end, num, base, field_width, precision, flags);
+  }
+  if (str <= end)
+    *str = '\0';
+  else if (cnt > 0)
+    /* don't write out a null byte if the buf size is zero */
+    *end = '\0';
+  return str-buf;
+}
+
+
+/*
+ * @implemented
+ */
+int lnx_sprintf(char * buf, const char *fmt, ...)
+{
+  va_list args;
+  int i;
+
+  va_start(args, fmt);
+  i=lnx_vsnprintf(buf,MAXLONG,fmt,args);
+  va_end(args);
+  return i;
+}
+
+#if 0
+/*
+ * @implemented
+ */
+int _snprintf(char * buf, size_t cnt, const char *fmt, ...)
+{
+  va_list args;
+  int i;
+
+  va_start(args, fmt);
+  i=_vsnprintf(buf,cnt,fmt,args);
+  va_end(args);
+  return i;
+}
+
+
+/*
+ * @implemented
+ */
+int __cdecl vsprintf(char *buf, const char *fmt, va_list args)
+{
+  return _vsnprintf(buf,MAXLONG,fmt,args);
+}
+#endif
+/* EOF */

lib/sdk/crt/stdio/perror.c

@@ -0,0 +1,23 @@
+/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
+#include <precomp.h>
+
+#ifdef perror
+#undef perror
+void perror(const char *s);
+#endif
+
+/*
+ * @implemented
+ */
+void perror(const char *s)
+{
+  fprintf(stderr, "%s: %s\n", s, _strerror(NULL));
+}
+
+/*
+ * @implemented
+ */
+void _wperror(const wchar_t *s)
+{
+  fwprintf(stderr, L"%s: %S\n", s, _strerror(NULL));
+}

lib/sdk/crt/stdio/popen.c

@@ -0,0 +1,144 @@
+/*
+* COPYRIGHT:   See COPYING in the top level directory
+* PROJECT:     ReactOS C runtime library
+* FILE:        lib/sdk/crt/stdio/popen.c
+* PURPOSE:     Pipe Functions
+* PROGRAMERS:  Eric Kohl
+               Hartmut Birr
+*/
+
+#include <precomp.h>
+#include <tchar.h>
+
+#ifdef _UNICODE
+#define sT "S"
+#else
+#define sT "s"
+#endif
+
+#define MK_STR(s) #s
+
+int alloc_fd(HANDLE hand, int flag); //FIXME: Remove
+unsigned split_oflags(unsigned oflags); //FIXME: Remove
+
+/*
+ * @implemented
+ */
+FILE *_tpopen (const _TCHAR *cm, const _TCHAR *md) /* program name, pipe mode */
+{
+    _TCHAR *szCmdLine=NULL;
+    _TCHAR *szComSpec=NULL;
+    _TCHAR *s;
+    FILE *pf;
+    HANDLE hReadPipe, hWritePipe;
+    BOOL result;
+    STARTUPINFO StartupInfo;
+    PROCESS_INFORMATION ProcessInformation;
+    SECURITY_ATTRIBUTES sa = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
+
+    TRACE(MK_STR(_tpopen)"('%"sT"', '%"sT"')\n", cm, md);
+
+    if (cm == NULL)
+        return( NULL );
+
+    szComSpec = _tgetenv(_T("COMSPEC"));
+    if (szComSpec == NULL)
+    {
+        szComSpec = _T("cmd.exe");
+    }
+
+    s = max(_tcsrchr(szComSpec, '\\'), _tcsrchr(szComSpec, '/'));
+    if (s == NULL)
+        s = szComSpec;
+    else
+        s++;
+
+    szCmdLine = malloc((_tcslen(s) + 4 + _tcslen(cm) + 1) * sizeof(_TCHAR));
+    if (szCmdLine == NULL)
+    {
+        return NULL;
+    }
+
+    _tcscpy(szCmdLine, s);
+    s = _tcsrchr(szCmdLine, '.');
+    if (s)
+        *s = 0;
+    _tcscat(szCmdLine, _T(" /C "));
+    _tcscat(szCmdLine, cm);
+
+    if ( !CreatePipe(&hReadPipe,&hWritePipe,&sa,1024))
+    {
+        free (szCmdLine);
+        return NULL;
+    }
+
+    memset(&StartupInfo, 0, sizeof(STARTUPINFO));
+    StartupInfo.cb = sizeof(STARTUPINFO);
+
+    if (*md == 'r' ) {
+        StartupInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
+        StartupInfo.hStdOutput = hWritePipe;
+        StartupInfo.dwFlags |= STARTF_USESTDHANDLES;
+    }
+    else if ( *md == 'w' ) {
+        StartupInfo.hStdInput = hReadPipe;
+        StartupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
+        StartupInfo.dwFlags |= STARTF_USESTDHANDLES;
+    }
+
+    if (StartupInfo.dwFlags & STARTF_USESTDHANDLES)
+        StartupInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
+
+    result = CreateProcess(szComSpec,
+        szCmdLine,
+        NULL,
+        NULL,
+        TRUE,
+        0,
+        NULL,
+        NULL,
+        &StartupInfo,
+        &ProcessInformation);
+    free (szCmdLine);
+
+    if (result == FALSE)
+    {
+        CloseHandle(hReadPipe);
+        CloseHandle(hWritePipe);
+        return NULL;
+    }
+
+    CloseHandle(ProcessInformation.hThread);
+
+    if ( *md == 'r' )
+    {
+        pf = _tfdopen(alloc_fd(hReadPipe,  split_oflags(_fmode)) , _T("r"));
+        CloseHandle(hWritePipe);
+    }
+    else
+    {
+        pf = _tfdopen( alloc_fd(hWritePipe, split_oflags(_fmode)) , _T("w"));
+        CloseHandle(hReadPipe);
+    }
+
+    return( pf );
+}
+
+#ifndef _UNICODE
+
+/*
+ * @implemented
+ */
+int _pclose (FILE *pp)
+{
+    TRACE("_pclose(%x)",pp);
+
+    fclose(pp);
+    //if (!TerminateProcess(pp->_tmpfname ,0))
+    //  return( -1 );
+    return( 0 );
+}
+
+#endif
+
+

lib/sdk/crt/stdio/stat.c

@@ -0,0 +1,62 @@
+#include <precomp.h>
+#include <tchar.h>
+
+#define stat64_to_stat(buf64, buf)   \
+    buf->st_dev   = (buf64)->st_dev;   \
+    buf->st_ino   = (buf64)->st_ino;   \
+    buf->st_mode  = (buf64)->st_mode;  \
+    buf->st_nlink = (buf64)->st_nlink; \
+    buf->st_uid   = (buf64)->st_uid;   \
+    buf->st_gid   = (buf64)->st_gid;   \
+    buf->st_rdev  = (buf64)->st_rdev;  \
+    buf->st_size  = (buf64)->st_size;  \
+    buf->st_atime = (buf64)->st_atime; \
+    buf->st_mtime = (buf64)->st_mtime; \
+    buf->st_ctime = (buf64)->st_ctime; \
+
+int CDECL _tstat(const _TCHAR* path, struct _stat * buf)
+{
+  int ret;
+  struct __stat64 buf64;
+
+  ret = _tstat64(path, &buf64);
+  if (!ret)
+    stat64_to_stat(&buf64, buf);
+  return ret;
+}
+
+int CDECL _tstati64(const _TCHAR* path, struct _stati64 * buf)
+{
+  int ret;
+  struct __stat64 buf64;
+
+  ret = _tstat64(path, &buf64);
+  if (!ret)
+    stat64_to_stat(&buf64, buf);
+  return ret;
+}
+
+#ifndef _UNICODE
+
+int CDECL _fstat(int fd, struct _stat* buf)
+{ int ret;
+  struct __stat64 buf64;
+
+  ret = _fstat64(fd, &buf64);
+  if (!ret)
+      stat64_to_stat(&buf64, buf);
+  return ret;
+}
+
+int CDECL _fstati64(int fd, struct _stati64* buf)
+{
+  int ret;
+  struct __stat64 buf64;
+
+  ret = _fstat64(fd, &buf64);
+  if (!ret)
+    stat64_to_stat(&buf64, buf);
+  return ret;
+}
+
+#endif

lib/sdk/crt/stdio/stat64.c

@@ -0,0 +1,146 @@
+#include <precomp.h>
+#include <tchar.h>
+#include <direct.h>
+
+HANDLE fdtoh(int fd); 
+
+#define ALL_S_IREAD  (_S_IREAD  | (_S_IREAD  >> 3) | (_S_IREAD  >> 6))
+#define ALL_S_IWRITE (_S_IWRITE | (_S_IWRITE >> 3) | (_S_IWRITE >> 6))
+#define ALL_S_IEXEC  (_S_IEXEC  | (_S_IEXEC  >> 3) | (_S_IEXEC  >> 6))
+
+#ifdef UNICODE
+#define TCHAR4 ULONGLONG
+#else
+#define TCHAR4 ULONG
+#endif
+
+#define TCSIZE sizeof(_TCHAR)
+#define TOULL(x) ((TCHAR4)(x))
+
+#define EXE ((TOULL('e')<<(2*TCSIZE)) | (TOULL('x')<<TCSIZE) | (TOULL('e')))
+#define BAT ((TOULL('b')<<(2*TCSIZE)) | (TOULL('a')<<TCSIZE) | (TOULL('t')))
+#define CMD ((TOULL('c')<<(2*TCSIZE)) | (TOULL('m')<<TCSIZE) | (TOULL('d')))
+#define COM ((TOULL('c')<<(2*TCSIZE)) | (TOULL('o')<<TCSIZE) | (TOULL('m')))
+
+int CDECL _tstat64(const _TCHAR *path, struct __stat64 *buf)
+{
+  DWORD dw;
+  WIN32_FILE_ATTRIBUTE_DATA hfi;
+  unsigned short mode = ALL_S_IREAD;
+  int plen;
+
+  TRACE(":file (%s) buf(%p)\n",path,buf);
+
+  if (!GetFileAttributesEx(path, GetFileExInfoStandard, &hfi))
+  {
+      TRACE("failed (%d)\n",GetLastError());
+      _dosmaperr(ERROR_FILE_NOT_FOUND);
+      return -1;
+  }
+
+  memset(buf,0,sizeof(struct __stat64));
+
+  /* FIXME: rdev isn't drive num, despite what the docs say-what is it?
+     Bon 011120: This FIXME seems incorrect
+                 Also a letter as first char isn't enough to be classified
+		 as a drive letter
+  */
+  if (isalpha(*path)&& (*(path+1)==':'))
+    buf->st_dev = buf->st_rdev = _totupper(*path) - 'A'; /* drive num */
+  else
+    buf->st_dev = buf->st_rdev = _getdrive() - 1;
+
+  plen = _tcslen(path);
+
+  /* Dir, or regular file? */
+  if ((hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
+      (path[plen-1] == '\\'))
+    mode |= (_S_IFDIR | ALL_S_IEXEC);
+  else
+  {
+    mode |= _S_IFREG;
+    /* executable? */
+    if (plen > 6 && path[plen-4] == '.')  /* shortest exe: "\x.exe" */
+    {
+      TCHAR4 ext = _totlower(path[plen-1]) | (_totlower(path[plen-2]) << TCSIZE) |
+                                 (_totlower(path[plen-3]) << (2*TCSIZE));
+      if (ext == EXE || ext == BAT || ext == CMD || ext == COM)
+          mode |= ALL_S_IEXEC;
+    }
+  }
+
+  if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
+    mode |= ALL_S_IWRITE;
+
+  buf->st_mode  = mode;
+  buf->st_nlink = 1;
+  buf->st_size  = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
+  RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
+  buf->st_atime = dw;
+  RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
+  buf->st_mtime = buf->st_ctime = dw;
+  TRACE("%d %d 0x%08lx%08lx %ld %ld %ld\n", buf->st_mode,buf->st_nlink,
+        (long)(buf->st_size >> 32),(long)buf->st_size,
+        (long)buf->st_atime,(long)buf->st_mtime,(long)buf->st_ctime);
+  return 0;
+}
+
+#ifndef _UNICODE
+
+int CDECL _fstat64(int fd, struct __stat64* buf)
+{
+  DWORD dw;
+  DWORD type;
+  BY_HANDLE_FILE_INFORMATION hfi;
+  HANDLE hand = fdtoh(fd);
+
+  TRACE(":fd (%d) stat (%p)\n",fd,buf);
+  if (hand == INVALID_HANDLE_VALUE)
+    return -1;
+
+  if (!buf)
+  {
+    WARN(":failed-NULL buf\n");
+    _dosmaperr(ERROR_INVALID_PARAMETER);
+    return -1;
+  }
+
+  memset(&hfi, 0, sizeof(hfi));
+  memset(buf, 0, sizeof(struct __stat64));
+  type = GetFileType(hand);
+  if (type == FILE_TYPE_PIPE)
+  {
+    buf->st_dev = buf->st_rdev = fd;
+    buf->st_mode = _S_IFIFO;
+    buf->st_nlink = 1;
+  }
+  else if (type == FILE_TYPE_CHAR)
+  {
+    buf->st_dev = buf->st_rdev = fd;
+    buf->st_mode = _S_IFCHR;
+    buf->st_nlink = 1;
+  }
+  else /* FILE_TYPE_DISK etc. */
+  {
+    if (!GetFileInformationByHandle(hand, &hfi))
+    {
+      WARN(":failed-last error (%d)\n",GetLastError());
+      _dosmaperr(ERROR_INVALID_PARAMETER);
+      return -1;
+    }
+    buf->st_mode = _S_IFREG | ALL_S_IREAD;
+    if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
+      buf->st_mode |= ALL_S_IWRITE;
+    buf->st_size  = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
+    RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
+    buf->st_atime = dw;
+    RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
+    buf->st_mtime = buf->st_ctime = dw;
+    buf->st_nlink = hfi.nNumberOfLinks;
+  }
+  TRACE(":dwFileAttributes = 0x%x, mode set to 0x%x\n",hfi.dwFileAttributes,
+   buf->st_mode);
+  return 0;
+}
+
+#endif

lib/sdk/crt/stdio/waccess.c

@@ -0,0 +1,4 @@
+#define UNICODE
+#define _UNICODE
+
+#include "access.c"

lib/sdk/crt/stdio/wfind.c

@@ -0,0 +1,9 @@
+#define UNICODE
+#define _UNICODE
+
+#include <precomp.h>
+#include <tchar.h>
+#include <io.h>
+
+// Generate _findfirst and _findnext
+#include "findgen.c"

lib/sdk/crt/stdio/wfind64.c

@@ -0,0 +1,16 @@
+#define UNICODE
+#define _UNICODE
+
+#include <precomp.h>
+#include <tchar.h>
+#include <io.h>
+
+// Generate _findfirst64 and _findnext64
+#undef _wfindfirst
+#define _wfindfirst _wfindfirst64
+#undef _wfindnext
+#define _wfindnext _wfindnext64
+#undef _wfinddata_t
+#define _wfinddata_t _wfinddata64_t
+
+#include "findgen.c"

lib/sdk/crt/stdio/wfindi64.c

@@ -0,0 +1,16 @@
+#define UNICODE
+#define _UNICODE
+
+#include <precomp.h>
+#include <tchar.h>
+#include <io.h>
+
+// Generate _findfirsti64 and _findnexti64
+#undef _wfindfirst
+#define _wfindfirst _wfindfirsti64
+#undef _wfindnext
+#define _wfindnext _wfindnexti64
+#undef _wfinddata_t
+#define _wfinddata_t _wfinddatai64_t
+
+#include "findgen.c"

lib/sdk/crt/stdio/wpopen.c

@@ -0,0 +1,5 @@
+#define _UNICODE
+#define UNICODE
+
+#include "popen.c"
+

lib/sdk/crt/stdio/wstat.c

@@ -0,0 +1,4 @@
+#define UNICODE
+#define _UNICODE
+
+#include "stat.c"

lib/sdk/crt/stdio/wstat64.c

@@ -0,0 +1,4 @@
+#define UNICODE
+#define _UNICODE
+
+#include "stat64.c"