[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] r387 - in GNUnet/src: include util/win
From: |
durner |
Subject: |
[GNUnet-SVN] r387 - in GNUnet/src: include util/win |
Date: |
Sun, 6 Mar 2005 02:24:29 -0800 (PST) |
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
[Prev in Thread] |
Current Thread |
[Next in Thread] |
- [GNUnet-SVN] r387 - in GNUnet/src: include util/win,
durner <=