1 /**
2  * D header file for C99.
3  *
4  * Copyright: Public Domain
5  * License:   Public Domain
6  * Authors:   Sean Kelly, Walter Bright
7  * Standards: ISO/IEC 9899:1999 (E)
8  */
9 module tango.stdc.stdio;
10 
11 private
12 {
13     import tango.stdc.stdarg;
14     import tango.stdc.stddef;
15     import tango.stdc.config;
16 }
17 
18 extern (C){
19 
20     version( Win32 )
21     {
22         const int BUFSIZ         = 0x4000;
23         const int EOF            = -1;
24         const int FOPEN_MAX      = 20;
25         const int FILENAME_MAX   = 256; // 255 plus NULL
26         const int TMP_MAX        = 32767;
27         const int _SYS_OPEN      = 20;
28         const int SYS_OPEN       = _SYS_OPEN;
29 
30         const int     _NFILE     = 60;
31         const char[]  _P_tmpdir  = "\\";
32         const wchar[] _wP_tmpdir = "\\";
33         const int     L_tmpnam   = _P_tmpdir.length + 12;
34     }
35     else version( linux )
36     {
37         //const int BUFSIZ      = 0x4000;
38         const int EOF           = -1;
39         const int FOPEN_MAX     = 16;
40         const int FILENAME_MAX  = 4095;
41         const int TMP_MAX       = 238328;
42         const int L_tmpnam      = 20;
43     }
44     else version(OSX)
45     {
46         const int EOF           = -1;
47         const int FOPEN_MAX     = 20;
48         const int FILENAME_MAX  = 1024;
49         const int TMP_MAX       = 308915776;
50         const int L_tmpnam      = 1024;
51 
52         private
53         {
54             struct __sbuf
55             {
56                 ubyte*  _base;
57                 int     _size;
58             }
59 
60             struct __sFILEX
61             {
62 
63             }
64         }
65     }
66     else version (FreeBSD)
67     {
68         const int EOF           = -1;
69         const int FOPEN_MAX     = 20;
70         const int FILENAME_MAX  = 1024;
71         const int TMP_MAX       = 308915776;
72         const int L_tmpnam      = 1024;
73 
74         private
75         {
76             struct __sbuf
77             {
78                 ubyte *_base;
79                 int _size;
80             }
81             struct __sFILEX
82             {
83             }
84         }
85     }
86     else version( solaris )
87     {
88         const int BUFSIZ      = 1024;
89         const int EOF           = -1;
90       version (X86_64) {
91         const int _NFILE        = 60;
92       } else {
93         const int _NFILE        = 20;
94       }
95         const int FOPEN_MAX     = _NFILE;
96     
97         const int FILENAME_MAX  = 1024;
98         const int TMP_MAX       = 17576;
99         const int L_tmpnam      = 25;
100     }
101     else
102     {
103         static assert( false );
104     }
105 
106     enum
107     {
108         SEEK_SET,
109         SEEK_CUR,
110         SEEK_END
111     }
112 
113     struct _iobuf
114     {
115         align (1):
116         version( Win32 )
117         {
118             char* _ptr;
119             int   _cnt;
120             char* _base;
121             int   _flag;
122             int   _file;
123             int   _charbuf;
124             int   _bufsiz;
125             int   __tmpnum;
126         }
127         else version( linux )
128         {
129             char*   _read_ptr;
130             char*   _read_end;
131             char*   _read_base;
132             char*   _write_base;
133             char*   _write_ptr;
134             char*   _write_end;
135             char*   _buf_base;
136             char*   _buf_end;
137             char*   _save_base;
138             char*   _backup_base;
139             char*   _save_end;
140             void*   _markers;
141             _iobuf* _chain;
142             int     _fileno;
143             int     _blksize;
144             int     _old_offset;
145             ushort  _cur_column;
146             byte    _vtable_offset;
147             char[1] _shortbuf;
148             void*   _lock;
149         }
150         else version(OSX)
151         {
152             ubyte*    _p;
153             int       _r;
154             int       _w;
155             short     _flags;
156             short     _file;
157             __sbuf    _bf;
158             int       _lbfsize;
159 
160             int* function(void*)                    _close;
161             int* function(void*, char*, int)        _read;
162             fpos_t* function(void*, fpos_t, int)    _seek;
163             int* function(void*, char *, int)       _write;
164 
165             __sbuf    _ub;
166             __sFILEX* _extra;
167             int       _ur;
168 
169             ubyte[3]  _ubuf;
170             ubyte[1]  _nbuf;
171 
172             __sbuf    _lb;
173 
174             int       _blksize;
175             fpos_t    _offset;
176         }
177         else version( FreeBSD )
178         {
179             ubyte*    _p;
180             int       _r;
181             int       _w;
182             short     _flags;
183             short     _file;
184             __sbuf    _bf;
185             int       _lbfsize;
186 
187             void* function()                        _cookie;
188             int* function(void*)                    _close;
189             int* function(void*, char*, int)        _read;
190             fpos_t* function(void*, fpos_t, int)    _seek;
191             int* function(void*, char *, int)       _write;
192 
193             __sbuf    _ub;
194             __sFILEX* _extra;
195             int       _ur;
196 
197             ubyte[3]  _ubuf;
198             ubyte[1]  _nbuf;
199 
200             __sbuf    _lb;
201 
202             int       _blksize;
203             fpos_t    _offset;
204         }
205         else version( solaris )
206         {
207             // From OpenSolaris <ast/sfio_s.h>
208             ubyte*  _next;  /* next position to read/write from */
209             ubyte*  _endw;  /* end of write buffer          */
210             ubyte*  _endr;  /* end of read buffer           */
211             ubyte*  _endb;  /* end of buffer            */
212             _iobuf* _push;  /* the stream that was pushed on    */
213             ushort  _flags; /* type of stream           */
214             short   _file;  /* file descriptor          */
215             ubyte*  _data;  /* base of data buffer          */
216             ptrdiff_t _size;  /* buffer size              */
217             ptrdiff_t _val;   /* values or string lengths     */
218         
219         //  #ifdef _SFIO_PRIVATE
220             // .. I don't think we really need this in D
221         //  #endif
222         }
223         else
224         {
225             static assert( false );
226         }
227     }
228 
229     alias _iobuf FILE;
230 
231     enum
232     {
233         _F_RDWR = 0x0003,
234         _F_READ = 0x0001,
235         _F_WRIT = 0x0002,
236         _F_BUF  = 0x0004,
237         _F_LBUF = 0x0008,
238         _F_ERR  = 0x0010,
239         _F_EOF  = 0x0020,
240         _F_BIN  = 0x0040,
241         _F_IN   = 0x0080,
242         _F_OUT  = 0x0100,
243         _F_TERM = 0x0200,
244     }
245 }
246 version( Win32 )
247 {
248     enum
249     {
250         _IOFBF   = 0,
251         _IOREAD  = 1,
252         _IOWRT   = 2,
253         _IONBF   = 4,
254         _IOMYBUF = 8,
255         _IOEOF   = 0x10,
256         _IOERR   = 0x20,
257         _IOLBF   = 0x40,
258         _IOSTRG  = 0x40,
259         _IORW    = 0x80,
260         _IOTRAN  = 0x100,
261         _IOAPP   = 0x200,
262     }
263 
264     extern extern(C) void function() _fcloseallp;
265 
266     version (GNU)
267     {
268         extern(C){
269             extern __gshared FILE[_NFILE]* _imp___iob;
270         }
271 
272         __gshared FILE* stdin;
273         __gshared FILE* stdout;
274         __gshared FILE* stderr;
275         __gshared FILE* stdaux;
276         __gshared FILE* stdprn;
277 
278         shared static this()
279         {
280             stdin  = &(*_imp___iob)[0];
281             stdout = &(*_imp___iob)[1];
282             stderr = &(*_imp___iob)[2];
283             stdaux = &(*_imp___iob)[3];
284             stdprn = &(*_imp___iob)[4];
285         }
286     }
287     else version (LDC) {
288         extern(C){
289             extern __gshared FILE[_NFILE]* _imp___iob;
290         }
291 
292         __gshared FILE* stdin;
293         __gshared FILE* stdout;
294         __gshared FILE* stderr;
295         __gshared FILE* stdaux;
296         __gshared FILE* stdprn;
297 
298         shared static this()
299         {
300             stdin  = &(*_imp___iob)[0];
301             stdout = &(*_imp___iob)[1];
302             stderr = &(*_imp___iob)[2];
303             stdaux = &(*_imp___iob)[3];
304             stdprn = &(*_imp___iob)[4];
305         }
306     }
307     else
308     {
309         extern(C){
310             extern __gshared FILE[_NFILE] _iob;
311         }
312 
313        __gshared FILE* stdin  = &_iob[0];
314        __gshared FILE* stdout = &_iob[1];
315        __gshared FILE* stderr = &_iob[2];
316        __gshared FILE* stdaux = &_iob[3];
317        __gshared FILE* stdprn = &_iob[4];
318     }
319 } else version( linux ) {
320     enum
321     {
322         _IOFBF = 0,
323         _IOLBF = 1,
324         _IONBF = 2,
325     }
326 
327     extern(C) extern __gshared FILE* stdin;
328     extern(C) extern __gshared FILE* stdout;
329     extern(C) extern __gshared FILE* stderr;
330 }
331 else version(OSX)
332 {
333     extern(C) extern __gshared FILE* __stdinp;
334     extern(C) extern __gshared FILE* __stdoutp;
335     extern(C) extern __gshared FILE* __stderrp;
336 
337     __gshared FILE* stdin;
338     __gshared FILE* stdout;
339     __gshared FILE* stderr;
340 
341     shared static this()
342     {
343         stdin  = __stdinp;
344         stdout = __stdoutp;
345         stderr = __stderrp;
346     }
347 }
348 else version( FreeBSD )
349 {
350     extern(C) extern __gshared FILE* __stdinp;
351     extern(C) extern __gshared FILE* __stdoutp;
352     extern(C) extern __gshared FILE* __stderrp;
353 
354     __gshared FILE* stdin;
355     __gshared FILE* stdout;
356     __gshared FILE* stderr;
357 
358     shared static this()
359     {
360         stdin  = __stdinp;
361         stdout = __stdoutp;
362         stderr = __stderrp;
363     }
364 }
365 else version( solaris )
366 {
367     extern(C) extern __gshared FILE[_NFILE] __iob;
368     
369     __gshared FILE* stdin  = &__iob[0];
370     __gshared FILE* stdout = &__iob[1];
371     __gshared FILE* stderr = &__iob[2];
372 }
373 else
374 {
375     static assert( false );
376 }
377 
378 alias int fpos_t;
379 
380 extern(C){
381     int remove(in char* filename);
382     int rename(in char* from, in char* to);
383 
384     FILE* tmpfile();
385     char* tmpnam(char* s);
386 
387     int   fclose(FILE* stream);
388     int   fflush(FILE* stream);
389     FILE* fopen(in char* filename, in char* mode);
390     FILE* freopen(in char* filename, in char* mode, FILE* stream);
391 
392     void setbuf(FILE* stream, char* buf);
393     int  setvbuf(FILE* stream, char* buf, int mode, size_t size);
394 
395     int fprintf(FILE* stream, in char* format, ...);
396     int fscanf(FILE* stream, in char* format, ...);
397     int sprintf(char* s, in char* format, ...);
398     int sscanf(in char* s, in char* format, ...);
399     int vfprintf(FILE* stream, in char* format, va_list arg);
400     int vfscanf(FILE* stream, in char* format, va_list arg);
401     int vsprintf(char* s, in char* format, va_list arg);
402     int vsscanf(in char* s, in char* format, va_list arg);
403     int vprintf(in char* format, va_list arg);
404     int vscanf(in char* format, va_list arg);
405     int printf(in char* format, ...);
406     int scanf(in char* format, ...);
407 
408     int fgetc(FILE* stream);
409     int fputc(int c, FILE* stream);
410 
411     char* fgets(char* s, int n, FILE* stream);
412     int   fputs(in char* s, FILE* stream);
413     char* gets(char* s);
414     int   puts(in char* s);
415 }
416 
417 extern (D)
418 {
419     int getchar()                 { return getc(stdin);     }
420     int putchar(int c)            { return putc(c,stdout);  }
421     int getc(FILE* stream)        { return fgetc(stream);   }
422     int putc(int c, FILE* stream) { return fputc(c,stream); }
423 }
424 
425 extern(C) {
426     int ungetc(int c, FILE* stream);
427 
428     size_t fread(void* ptr, size_t size, size_t nmemb, FILE* stream);
429     size_t fwrite(in void* ptr, size_t size, size_t nmemb, FILE* stream);
430 
431     int fgetpos(FILE* stream, fpos_t * pos);
432     int fsetpos(FILE* stream, in fpos_t* pos);
433 
434     int    fseek(FILE* stream, c_long offset, int whence);
435     c_long ftell(FILE* stream);
436 }
437 
438 extern(C):
439 
440 version( Win32 )
441 {
442   extern (D)
443   {
444     void rewind(FILE* stream)   { fseek(stream,0L,SEEK_SET); stream._flag&=~_IOERR; }
445     void clearerr(FILE* stream) { stream._flag &= ~(_IOERR|_IOEOF);                 }
446     int  feof(FILE* stream)     { return stream._flag&_IOEOF;                       }
447     int  ferror(FILE* stream)   { return stream._flag&_IOERR;                       }
448   }
449     int   _snprintf(char* s, size_t n, in char* fmt, ...);
450     alias _snprintf snprintf;
451 
452     int   _vsnprintf(char* s, size_t n, in char* format, va_list arg);
453     alias _vsnprintf vsnprintf;
454 }
455 else version( linux )
456 {
457     void rewind(FILE* stream);
458     void clearerr(FILE* stream);
459     int  feof(FILE* stream);
460     int  ferror(FILE* stream);
461     int  fileno(FILE *);
462 
463     int  snprintf(char* s, size_t n, in char* format, ...);
464     int  vsnprintf(char* s, size_t n, in char* format, va_list arg);
465 }
466 else version(OSX)
467 {
468     void rewind(FILE*);
469     void clearerr(FILE*);
470     int  feof(FILE*);
471     int  ferror(FILE*);
472     int  fileno(FILE*);
473 
474     int  snprintf(char* s, size_t n, in char* format, ...);
475     int  vsnprintf(char* s, size_t n, in char* format, va_list arg);
476 }
477 else version( FreeBSD )
478 {
479     void rewind(FILE*);
480     void clearerr(FILE*);
481     int  feof(FILE*);
482     int  ferror(FILE*);
483     int  fileno(FILE*);
484 
485     int  snprintf(char* s, size_t n, in char* format, ...);
486     int  vsnprintf(char* s, size_t n, in char* format, va_list arg);
487 }
488 else version( solaris )
489 {
490     void rewind(FILE*);
491     void clearerr(FILE*);
492     int  feof(FILE*);
493     int  ferror(FILE*);
494     int  fileno(FILE*);
495 
496     int  snprintf(char* s, size_t n, in char* format, ...);
497     int  vsnprintf(char* s, size_t n, in char* format, va_list arg);    
498 }
499 else
500 {
501     static assert( false );
502 }
503 
504 void perror(in char* s);
505 
506 int fwprintf(FILE* stream, in wchar_t* format, ...);
507 int fwscanf(FILE* stream, in wchar_t* format, ...);
508 int swprintf(wchar_t* s, size_t n, in wchar_t* format, ...);
509 int swscanf(in wchar_t* s, in wchar_t* format, ...);
510 int vfwprintf(FILE* stream, in wchar_t* format, va_list arg);
511 int vfwscanf(FILE* stream, in wchar_t* format, va_list arg);
512 int vswprintf(wchar_t* s, size_t n, in wchar_t* format, va_list arg);
513 int vswscanf(in wchar_t* s, in wchar_t* format, va_list arg);
514 int vwprintf(in wchar_t* format, va_list arg);
515 int vwscanf(in wchar_t* format, va_list arg);
516 int wprintf(in wchar_t* format, ...);
517 int wscanf(in wchar_t* format, ...);
518 
519 wint_t fgetwc(FILE* stream);
520 wint_t fputwc(wchar_t c, FILE* stream);
521 
522 wchar_t* fgetws(wchar_t* s, int n, FILE* stream);
523 int      fputws(in wchar_t* s, FILE* stream);
524 
525 extern (D)
526 {
527     wint_t getwchar()                     { return fgetwc(stdin);     }
528     wint_t putwchar(wchar_t c)            { return fputwc(c,stdout);  }
529     wint_t getwc(FILE* stream)            { return fgetwc(stream);    }
530     wint_t putwc(wchar_t c, FILE* stream) { return fputwc(c, stream); }
531 }
532 
533 wint_t ungetwc(wint_t c, FILE* stream);
534 int    fwide(FILE* stream, int mode);