[GNUnet-SVN] r387 - in GNUnet/src: include util/win

[durner]

Author: durner
Date: 2005-03-06 02:24:28 -0800 (Sun, 06 Mar 2005)
New Revision: 387

Added:
   GNUnet/src/util/win/win_printf.c
Modified:
   GNUnet/src/include/platform.h
   GNUnet/src/include/winproc.h
   GNUnet/src/util/win/winproc.c
Log:
Unix compatible ("%llu") printf for Windows

Modified: GNUnet/src/include/platform.h
===================================================================
--- GNUnet/src/include/platform.h       2005-03-06 10:23:08 UTC (rev 386)
+++ GNUnet/src/include/platform.h       2005-03-06 10:24:28 UTC (rev 387)
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2001 - 2004 Christian Grothoff (and other contributing authors)
+     (C) 2001, 2002, 2003, 2004, 2005 Christian Grothoff (and other 
contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -191,6 +191,14 @@
  #define STRERROR(i) strerror(i)
  #define READLINK(p, b, s) readlink(p, b, s)
  #define LSTAT(p, b) lstat(p, b)
+ #define PRINTF(f, ...) printf(f , __VA_ARGS__)
+ #define FPRINTF(fil, fmt, ...) fprintf(fil, fmt, __VA_ARGS__)
+ #define VPRINTF(f, a) vprintf(f, a)
+ #define VFPRINTF(s, f, a) vfprintf(s, f, a)
+ #define VSPRINTF(d, f, a) vsprintf(d, f, a)
+ #define VSNPRINTF(str, size, fmt, a) vsnprintf(str, size, fmt, a)
+ #define _REAL_SNPRINTF(str, size, fmt, ...) snprintf(str, size, fmt, 
__VA_ARGS__)
+ #define SPRINTF(d, f, ...) sprintf(d, f, __VA_ARGS__)
  #define ACCEPT(s, a, l) accept(s, a, l)
  #define BIND(s, n, l) bind(s, n, l)
  #define CONNECT(s, n, l) connect(s, n, l)
@@ -235,6 +243,14 @@
  #define STRERROR(i) _win_strerror(i)
  #define READLINK(p, b, s) _win_readlink(p, b, s)
  #define LSTAT(p, b) _win_lstat(p, b)
+ #define PRINTF(f, ...) _win_printf(f , __VA_ARGS__)
+ #define FPRINTF(fil, fmt, ...) _win_fprintf(fil, fmt, __VA_ARGS__)
+ #define VPRINTF(f, a) _win_vprintf(f, a)
+ #define VFPRINTF(s, f, a) _win_vfprintf(s, f, a)
+ #define VSPRINTF(d, f, a) _win_vsprintf(d, f, a)
+ #define VSNPRINTF(str, size, fmt, a) _win_vsnprintf(str, size, fmt, a)
+ #define _REAL_SNPRINTF(str, size, fmt, ...) _win_snprintf(str, size, fmt, 
__VA_ARGS__)
+ #define SPRINTF(d, f, ...) _win_sprintf(d, f, __VA_ARGS__)
  #define ACCEPT(s, a, l) _win_accept(s, a, l)
  #define BIND(s, n, l) _win_bind(s, n, l)
  #define CONNECT(s, n, l) _win_connect(s, n, l)

Modified: GNUnet/src/include/winproc.h
===================================================================
--- GNUnet/src/include/winproc.h        2005-03-06 10:23:08 UTC (rev 386)
+++ GNUnet/src/include/winproc.h        2005-03-06 10:24:28 UTC (rev 387)
@@ -415,6 +415,14 @@
 int _win_lstat(const char *path, struct stat *buf);
 int _win_readlink(const char *path, char *buf, size_t bufsize);
 int _win_accept(SOCKET s, struct sockaddr *addr, int *addrlen);
+int _win_printf(const char *format,...);
+int _win_fprintf(FILE *f,const char *format,...);
+int _win_vprintf(const char *format, va_list ap);
+int _win_vfprintf(FILE *stream, const char *format, va_list arg_ptr);
+int _win_vsprintf(char *dest,const char *format, va_list arg_ptr);
+int _win_vsnprintf(char* str, size_t size, const char *format, va_list 
arg_ptr);
+int _win_snprintf(char *str,size_t size,const char *format,...);
+int _win_sprintf(char *dest,const char *format,...);
 int _win_bind(SOCKET s, const struct sockaddr *name, int namelen);
 int _win_connect(SOCKET s,const struct sockaddr *name, int namelen);
 int _win_getpeername(SOCKET s, struct sockaddr *name,

Added: GNUnet/src/util/win/win_printf.c
===================================================================
--- GNUnet/src/util/win/win_printf.c    2005-03-06 10:23:08 UTC (rev 386)
+++ GNUnet/src/util/win/win_printf.c    2005-03-06 10:24:28 UTC (rev 387)
@@ -0,0 +1,716 @@
+/*
+     This file is part of GNUnet.
+     (C) 2005 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file util/win/win_printf.c
+ * @brief Unix compatible printf for Windows
+ * @author Felix von Leitner
+ * @author Nils Durner
+ * @see <a href="http://www.fefe.de/dietlibc/";>diet libc</a>
+ */
+
+/* Stolen from Felix von Leitners "diet libc" 0.28 */
+ 
+#include <stdarg.h>
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#define WANT_ERROR_PRINTF 1
+#define WANT_LONGLONG_PRINTF 1
+#define WANT_NULL_PRINTF 1
+#define WANT_FLOATING_POINT_IN_PRINTF 1
+
+struct str_data {
+  unsigned char* str;
+  size_t len;
+  size_t size;
+};
+
+struct arg_printf {
+  void *data;
+  int (*put)(void*,size_t,void*);
+};
+
+static inline unsigned int skip_to(const unsigned char *format) {
+  unsigned int nr;
+  for (nr=0; format[nr] && (format[nr]!='%'); ++nr);
+  return nr;
+}
+
+#define A_WRITE(fn,buf,sz)     ((fn)->put((void*)(buf),(sz),(fn)->data))
+
+static const char pad_line[2][16]= { "                ", "0000000000000000", };
+static inline int write_pad(struct arg_printf* fn, int len, int padwith) {
+  int nr=0;
+  for (;len>15;len-=16,nr+=16) {
+    A_WRITE(fn,pad_line[(padwith=='0')?1:0],16);
+  }
+  if (len>0) {
+    A_WRITE(fn,pad_line[(padwith=='0')?1:0],(unsigned int)len); nr+=len;
+  }
+  return nr;
+}
+
+int __lltostr(char *s, int size, unsigned long long i, int base, char UpCase)
+{
+  char *tmp;
+  unsigned int j=0;
+
+  s[--size]=0;
+
+  tmp=s+size;
+
+  if ((base==0)||(base>36)) base=10;
+
+  j=0;
+  if (!i)
+  {
+    *(--tmp)='0';
+    j=1;
+  }
+
+  while((tmp>s)&&(i))
+  {
+    tmp--;
+    if ((*tmp=i%base+'0')>'9') *tmp+=(UpCase?'A':'a')-'9'-1;
+    i=i/base;
+    j++;
+  }
+  memmove(s,tmp,j+1);
+
+  return j;
+}
+
+int __ltostr(char *s, unsigned int size, unsigned long i, unsigned int base, 
int UpCase)
+{
+  char *tmp;
+  unsigned int j=0;
+
+  s[--size]=0;
+
+  tmp=s+size;
+
+  if ((base==0)||(base>36)) base=10;
+
+  j=0;
+  if (!i)
+  {
+    *(--tmp)='0';
+    j=1;
+  }
+
+  while((tmp>s)&&(i))
+  {
+    tmp--;
+    if ((*tmp=i%base+'0')>'9') *tmp+=(UpCase?'A':'a')-'9'-1;
+    i=i/base;
+    j++;
+  }
+  memmove(s,tmp,j+1);
+
+  return j;
+}
+
+static int copystring(char* buf,int maxlen, const char* s) {
+  int i;
+  for (i=0; i<3&&i<maxlen; ++i)
+    buf[i]=s[i];
+  if (i<maxlen) { buf[i]=0; ++i; }
+  return i;
+}
+
+int __dtostr(double d,char *buf,unsigned int maxlen,unsigned int prec,unsigned 
int prec2) {
+#if 1
+  union {
+    unsigned long long l;
+    double d;
+  } u = { .d=d };
+  /* step 1: extract sign, mantissa and exponent */
+  signed long e=((u.l>>52)&((1<<11)-1))-1023;
+#else
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+  signed long e=(((((unsigned long*)&d)[1])>>20)&((1<<11)-1))-1023;
+#else
+  signed long e=(((*((unsigned long*)&d))>>20)&((1<<11)-1))-1023;
+#endif
+#endif
+/*  unsigned long long m=u.l & ((1ull<<52)-1); */
+  /* step 2: exponent is base 2, compute exponent for base 10 */
+  signed long e10;
+  /* step 3: calculate 10^e10 */
+  unsigned int i;
+  double backup=d;
+  double tmp;
+  char *oldbuf=buf;
+
+  if ((i=isinf(d))) return copystring(buf,maxlen,i>0?"inf":"-inf");
+  if (isnan(d)) return copystring(buf,maxlen,"nan");
+  e10=1+(long)(e*0.30102999566398119802); /* log10(2) */
+  /* Wir iterieren von Links bis wir bei 0 sind oder maxlen erreicht
+   * ist.  Wenn maxlen erreicht ist, machen wir das nochmal in
+   * scientific notation.  Wenn dann von prec noch was �brig ist, geben
+   * wir einen Dezimalpunkt aus und geben prec2 Nachkommastellen aus.
+   * Wenn prec2 Null ist, geben wir so viel Stellen aus, wie von prec
+   * noch �brig ist. */
+  if (d==0.0) {
+    prec2=prec2==0?1:prec2+2;
+    prec2=prec2>maxlen?8:prec2;
+    i=0;
+    if (prec2 && (long long)u.l<0) { buf[0]='-'; ++i; }
+    for (; i<prec2; ++i) buf[i]='0';
+    buf[buf[0]=='0'?1:2]='.'; buf[i]=0;
+    return i;
+  }
+
+  if (d < 0.0) { d=-d; *buf='-'; --maxlen; ++buf; }
+
+   /*
+      Perform rounding. It needs to be done before we generate any
+      digits as the carry could propagate through the whole number.
+   */
+
+  tmp = 0.5;
+  for (i = 0; i < prec2; i++) { tmp *= 0.1; }
+  d += tmp;
+
+  if (d < 1.0) { *buf='0'; --maxlen; ++buf; }
+/*  printf("e=%d e10=%d prec=%d\n",e,e10,prec); */
+  if (e10>0) {
+    int first=1;       /* are we about to write the first digit? */
+    tmp = 10.0;
+    i=e10;
+    while (i>10) { tmp=tmp*1e10; i-=10; }
+    while (i>1) { tmp=tmp*10; --i; }
+    /* the number is greater than 1. Iterate through digits before the
+     * decimal point until we reach the decimal point or maxlen is
+     * reached (in which case we switch to scientific notation). */
+    while (tmp>0.9) {
+      char digit;
+      double fraction=d/tmp;
+       digit=(int)(fraction);          /* floor() */
+      if (!first || digit) {
+       first=0;
+       *buf=digit+'0'; ++buf;
+       if (!maxlen) {
+         /* use scientific notation */
+         int len=__dtostr(backup/tmp,oldbuf,maxlen,prec,prec2);
+         int initial=1;
+         if (len==0) return 0;
+         maxlen-=len; buf+=len;
+         if (maxlen>0) {
+           *buf='e';
+           ++buf;
+         }
+         --maxlen;
+         for (len=1000; len>0; len/=10) {
+           if (e10>=len || !initial) {
+             if (maxlen>0) {
+               *buf=(e10/len)+'0';
+               ++buf;
+             }
+             --maxlen;
+             initial=0;
+             e10=e10%len;
+           }
+         }
+         if (maxlen>0) goto fini;
+         return 0;
+       }
+       d-=digit*tmp;
+       --maxlen;
+      }
+      tmp/=10.0;
+    }
+  }
+  else
+  {
+     tmp = 0.1;
+  }
+
+  if (buf==oldbuf) {
+    if (!maxlen) return 0; --maxlen;
+    *buf='0'; ++buf;
+  }
+  if (prec2 || prec>(unsigned int)(buf-oldbuf)+1) {    /* more digits wanted */
+    if (!maxlen) return 0; --maxlen;
+    *buf='.'; ++buf;
+    prec-=buf-oldbuf-1;
+    if (prec2) prec=prec2;
+    if (prec>maxlen) return 0;
+    while (prec>0) {
+      char digit;
+      double fraction=d/tmp;
+      digit=(int)(fraction);           /* floor() */
+      *buf=digit+'0'; ++buf;
+      d-=digit*tmp;
+      tmp/=10.0;
+      --prec;
+    }
+  }
+fini:
+  *buf=0;
+  return buf-oldbuf;
+}
+
+int isinf(double d) {
+  union {
+    unsigned long long l;
+    double d;
+  } u;
+  u.d=d;
+  return (u.l==0x7FF0000000000000ll?1:u.l==0xFFF0000000000000ll?-1:0);
+}
+
+int __v_printf(struct arg_printf* fn, const unsigned char *format, va_list 
arg_ptr)
+{
+  int len=0;
+#ifdef WANT_ERROR_PRINTF
+  int _my_errno = errno;
+#endif
+
+  while (*format) {
+    unsigned int sz = skip_to(format);
+    if (sz) {
+      A_WRITE(fn,format,sz); len+=sz;
+      format+=sz;
+    }
+    if (*format=='%') {
+      char buf[128];
+      union { char*s; } u_str;
+#define s u_str.s
+
+      int retval;
+      unsigned char ch, padwith=' ';
+
+      char flag_in_sign=0;
+      char flag_upcase=0;
+      char flag_hash=0;
+      char flag_left=0;
+      char flag_space=0;
+      char flag_sign=0;
+      char flag_dot=0;
+      signed char flag_long=0;
+
+      unsigned int base;
+      unsigned int width=0, preci=0;
+
+      long number=0;
+#ifdef WANT_LONGLONG_PRINTF
+      long long llnumber=0;
+#endif
+
+      ++format;
+inn_printf:
+      switch(ch=*format++) {
+      case 0:
+       return -1;
+       break;
+
+      /* FLAGS */
+      case '#':
+       flag_hash=-1;
+      case 'z':
+       goto inn_printf;
+
+      case 'h':
+       --flag_long;
+       goto inn_printf;
+      case 'q':                /* BSD ... */
+      case 'L':
+       ++flag_long; /* fall through */
+      case 'l':
+       ++flag_long;
+       goto inn_printf;
+
+      case '-':
+       flag_left=1;
+       goto inn_printf;
+
+      case ' ':
+       flag_space=1;
+       goto inn_printf;
+
+      case '+':
+       flag_sign=1;
+       goto inn_printf;
+
+      case '0':
+      case '1':
+      case '2':
+      case '3':
+      case '4':
+      case '5':
+      case '6':
+      case '7':
+      case '8':
+      case '9':
+       if(flag_dot) return -1;
+       width=strtoul(format-1,(char**)&s,10);
+       if (ch=='0' && !flag_left) padwith='0';
+       format=s;
+       goto inn_printf;
+
+      case '*':
+       width=va_arg(arg_ptr,int);
+       goto inn_printf;
+
+      case '.':
+       flag_dot=1;
+       if (*format=='*') {
+         int tmp=va_arg(arg_ptr,int);
+         preci=tmp<0?0:tmp;
+         ++format;
+       } else {
+         long int tmp=strtol(format,(char**)&s,10);
+         preci=tmp<0?0:tmp;
+         format=s;
+       }
+       goto inn_printf;
+
+      /* print a char or % */
+      case 'c':
+       ch=(char)va_arg(arg_ptr,int);
+      case '%':
+       A_WRITE(fn,&ch,1); ++len;
+       break;
+
+#ifdef WANT_ERROR_PRINTF
+      /* print an error message */
+      case 'm':
+       s=strerror(_my_errno);
+       sz=strlen(s);
+       A_WRITE(fn,s,sz); len+=sz;
+       break;
+#endif
+      /* print a string */
+      case 's':
+       s=va_arg(arg_ptr,char *);
+#ifdef WANT_NULL_PRINTF
+       if (!s) s="(null)";
+#endif
+       sz = strlen(s);
+       if (flag_dot && sz>preci) sz=preci;
+       preci=0;
+       flag_dot^=flag_dot;
+       padwith=' ';
+
+print_out:
+      {
+       char *sign=s;
+       int todo=0;
+       int vs;
+       
+       if (! (width||preci) ) {
+         A_WRITE(fn,s,sz); len+=sz;
+         break;
+       }
+       
+       if (flag_in_sign) todo=1;
+       if (flag_hash>0)  todo=flag_hash;
+       if (todo) {
+         s+=todo;
+         sz-=todo;
+         width-=todo;
+       }
+       
+       if (!flag_left) {
+         if (flag_dot) {
+           vs=preci>sz?preci:sz;
+           len+=write_pad(fn,(signed int)width-(signed int)vs,' ');
+           if (todo) {
+             A_WRITE(fn,sign,todo);
+             len+=todo;
+           }
+           len+=write_pad(fn,(signed int)preci-(signed int)sz,'0');
+         } else {
+           if (todo && padwith=='0') {
+             A_WRITE(fn,sign,todo);
+             len+=todo; todo=0;
+           }
+           len+=write_pad(fn,(signed int)width-(signed int)sz, padwith);
+           if (todo) {
+             A_WRITE(fn,sign,todo);
+             len+=todo;
+           }
+         }
+         A_WRITE(fn,s,sz); len+=sz;
+       } else if (flag_left) {
+         if (todo) {
+           A_WRITE(fn,sign,todo);
+           len+=todo;
+         }
+         len+=write_pad(fn,(signed int)preci-(signed int)sz, '0');
+         A_WRITE(fn,s,sz); len+=sz;
+         vs=preci>sz?preci:sz;
+         len+=write_pad(fn,(signed int)width-(signed int)vs, ' ');
+       } else {
+         A_WRITE(fn,s,sz); len+=sz;
+       }
+       break;
+      }
+
+      /* print an integer value */
+      case 'b':
+       base=2;
+       sz=0;
+       goto num_printf;
+      case 'p':
+       flag_hash=2;
+       flag_long=1;
+       ch='x';
+      case 'X':
+       flag_upcase=(ch=='X');
+      case 'x':
+       base=16;
+       sz=0;
+       if (flag_hash) {
+         buf[1]='0';
+         buf[2]=ch;
+         flag_hash=2;
+         sz=2;
+       }
+       if (preci>width) width=preci;
+       goto num_printf;
+      case 'd':
+      case 'i':
+       flag_in_sign=1;
+      case 'u':
+       base=10;
+       sz=0;
+       goto num_printf;
+      case 'o':
+       base=8;
+       sz=0;
+       if (flag_hash) {
+         buf[1]='0';
+         flag_hash=1;
+         ++sz;
+       }
+
+num_printf:
+       s=buf+1;
+
+       if (flag_long>0) {
+#ifdef WANT_LONGLONG_PRINTF
+         if (flag_long>1)
+           llnumber=va_arg(arg_ptr,long long);
+         else
+#endif
+           number=va_arg(arg_ptr,long);
+       }
+       else
+         number=va_arg(arg_ptr,int);
+
+       if (flag_in_sign) {
+#ifdef WANT_LONGLONG_PRINTF
+         if ((flag_long>1)&&(llnumber<0)) {
+           llnumber=-llnumber;
+           flag_in_sign=2;
+         } else
+#endif
+           if (number<0) {
+             number=-number;
+             flag_in_sign=2;
+           }
+       }
+       if (flag_long<0) number&=0xffff;
+       if (flag_long<-1) number&=0xff;
+#ifdef WANT_LONGLONG_PRINTF
+       if (flag_long>1)
+         retval = __lltostr(s+sz,sizeof(buf)-5,(unsigned long long) 
llnumber,base,flag_upcase);
+       else
+#endif
+         retval = __ltostr(s+sz,sizeof(buf)-5,(unsigned long) 
number,base,flag_upcase);
+
+       /* When 0 is printed with an explicit precision 0, the output is empty. 
*/
+       if (flag_dot && retval == 1 && s[sz] == '0') {
+         if (preci == 0||flag_hash > 0) {
+           sz = 0;
+         }
+         flag_hash = 0;
+       } else sz += retval;
+
+       if (flag_in_sign==2) {
+         *(--s)='-';
+         ++sz;
+       } else if ((flag_in_sign)&&(flag_sign || flag_space)) {
+         *(--s)=(flag_sign)?'+':' ';
+         ++sz;
+       } else flag_in_sign=0;
+
+       goto print_out;
+
+#ifdef WANT_FLOATING_POINT_IN_PRINTF
+      /* print a floating point value */
+      case 'f':
+      case 'g':
+       {
+         int g=(ch=='g');
+         double d=va_arg(arg_ptr,double);
+         s=buf+1;
+         if (width==0) width=1;
+         if (!flag_dot) preci=6;
+         if (flag_sign || d < +0.0) flag_in_sign=1;
+         
+         sz=__dtostr(d,s,sizeof(buf)-1,width,preci);
+         
+         if (flag_dot) {
+           char *tmp;
+           if ((tmp=strchr(s,'.'))) {
+             if (preci || flag_hash) ++tmp;
+             while (preci>0 && *++tmp) --preci;
+             *tmp=0;
+           } else if (flag_hash) {
+             s[sz]='.';
+             s[++sz]='\0';
+           }
+         }
+
+         if (g) {
+           char *tmp,*tmp1;    /* boy, is _this_ ugly! */
+           if ((tmp=strchr(s,'.'))) {
+             tmp1=strchr(tmp,'e');
+             while (*tmp) ++tmp;
+             if (tmp1) tmp=tmp1;
+             while (*--tmp=='0') ;
+             if (*tmp!='.') ++tmp;
+             *tmp=0;
+             if (tmp1) strcpy(tmp,tmp1);
+           }
+         }
+         
+         if ((flag_sign || flag_space) && d>=0) {
+           *(--s)=(flag_sign)?'+':' ';
+           ++sz;
+         }
+         
+         sz=strlen(s);
+         flag_dot=0;
+         flag_hash=0;
+         goto print_out;
+       }
+#endif
+
+      default:
+       break;
+      }
+    }
+  }
+  return len;
+}
+
+#undef s
+
+static int swrite(void*ptr, size_t nmemb, struct str_data* sd) {
+  size_t tmp=sd->size-sd->len;
+  if (tmp>0) {
+    size_t len=nmemb;
+    if (len>tmp) len=tmp;
+    if (sd->str) {
+      memcpy(sd->str+sd->len,ptr,len);
+      sd->str[sd->len+len]=0;
+    }
+    sd->len+=len;
+  }
+  return nmemb;
+}
+
+int _win_vsnprintf(char* str, size_t size, const char *format, va_list arg_ptr)
+{
+  long n;
+  struct str_data sd = { str, 0, size?size-1:0 };
+  struct arg_printf ap = { &sd, (int(*)(void*,size_t,void*)) swrite };
+  n=__v_printf(&ap,format,arg_ptr);
+  if (str && size && n>=0) {
+    if (size!=(size_t)-1 && ((size_t)n>=size)) str[size-1]=0;
+    else str[n]=0;
+  }
+  return n;
+}
+
+int _win_vsprintf(char *dest, const char *format, va_list arg_ptr)
+{
+  return _win_vsnprintf(dest,(size_t)-1,format,arg_ptr);
+}
+
+static int __fwrite(void*ptr, size_t nmemb, int fd) {
+  return write(fd,ptr,nmemb);
+}
+
+int _win_vfprintf(FILE *stream, const char *format, va_list arg_ptr)
+{
+  struct arg_printf ap = { stream, (int(*)(void*,size_t,void*)) __fwrite };
+  return __v_printf(&ap,format,arg_ptr);
+}
+
+int __stdio_outs(const char *s, size_t len) {
+  return (write(1,s,len)==(int)len)?1:0;
+}
+
+int _win_vprintf(const char *format, va_list ap)
+{
+  struct arg_printf _ap = { 0, (int(*)(void*,size_t,void*)) __stdio_outs };
+  return __v_printf(&_ap,format,ap);
+}
+
+int _win_fprintf(FILE *f,const char *format, ...)
+{
+  int n;
+  va_list arg_ptr;
+  va_start(arg_ptr,format);
+  n=_win_vfprintf(f,format,arg_ptr);
+  va_end(arg_ptr);
+  return n;
+}
+
+int _win_printf(const char *format, ...)
+{
+  int n;
+  va_list arg_ptr;
+  va_start(arg_ptr, format);
+  n=_win_vprintf(format, arg_ptr);
+  va_end(arg_ptr);
+  return n;
+}
+
+int _win_snprintf(char *str, size_t size, const char *format, ...)
+{
+  int n;
+  va_list arg_ptr;
+  va_start(arg_ptr, format);
+  n=vsnprintf(str,size,format,arg_ptr);
+  va_end (arg_ptr);
+  return n;
+}
+
+int _win_sprintf(char *dest, const char *format, ...)
+{
+  int n;
+  va_list arg_ptr;
+  va_start(arg_ptr, format);
+  n=vsprintf(dest,format,arg_ptr);
+  va_end (arg_ptr);
+  return n;
+}
+
+/* end of win_printf.c */

Modified: GNUnet/src/util/win/winproc.c
===================================================================
--- GNUnet/src/util/win/winproc.c       2005-03-06 10:23:08 UTC (rev 386)
+++ GNUnet/src/util/win/winproc.c       2005-03-06 10:24:28 UTC (rev 387)
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2001 - 2005 Christian Grothoff (and other contributing authors)
+     (C) 2001, 2002, 2003, 2004, 2005 Christian Grothoff (and other 
contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published