// D import file generated from 'stdc\stdio.d'
module tango.stdc.stdio;
private 
{
    import tango.stdc.stdarg;
    import tango.stdc.stddef;
    import tango.stdc.config;
}
extern (C) 
{
    version (Win32)
{
    const 
{
    int BUFSIZ = 16384;
}
    const 
{
    int EOF = -1;
}
    const 
{
    int FOPEN_MAX = 20;
}
    const 
{
    int FILENAME_MAX = 256;
}
    const 
{
    int TMP_MAX = 32767;
}
    const 
{
    int _SYS_OPEN = 20;
}
    const 
{
    int SYS_OPEN = _SYS_OPEN;
}
    const 
{
    int _NFILE = 60;
}
    const 
{
    char[] _P_tmpdir = "\\";
}
    const 
{
    wchar[] _wP_tmpdir = "\\";
}
    const 
{
    int L_tmpnam = _P_tmpdir.length + 12;
}
}
else
{
    version (linux)
{
    const 
{
    int EOF = -1;
}
    const 
{
    int FOPEN_MAX = 16;
}
    const 
{
    int FILENAME_MAX = 4095;
}
    const 
{
    int TMP_MAX = 238328;
}
    const 
{
    int L_tmpnam = 20;
}
}
else
{
    version (darwin)
{
    const 
{
    int EOF = -1;
}
    const 
{
    int FOPEN_MAX = 20;
}
    const 
{
    int FILENAME_MAX = 1024;
}
    const 
{
    int TMP_MAX = 308915776;
}
    const 
{
    int L_tmpnam = 1024;
}
    private 
{
    struct __sbuf
{
    ubyte* _base;
    int _size;
}
    struct __sFILEX
{
}
}
}
else
{
    version (freebsd)
{
    const 
{
    int EOF = -1;
}
    const 
{
    int FOPEN_MAX = 20;
}
    const 
{
    int FILENAME_MAX = 1024;
}
    const 
{
    int TMP_MAX = 308915776;
}
    const 
{
    int L_tmpnam = 1024;
}
    private 
{
    struct __sbuf
{
    ubyte* _base;
    int _size;
}
    struct __sFILEX
{
}
}
}
else
{
    version (solaris)
{
    const 
{
    int BUFSIZ = 1024;
}
    const 
{
    int EOF = -1;
}
    version (X86_64)
{
    const 
{
    int _NFILE = 60;
}
}
else
{
    const 
{
    int _NFILE = 20;
}
}
    const 
{
    int FOPEN_MAX = _NFILE;
}
    const 
{
    int FILENAME_MAX = 1024;
}
    const 
{
    int TMP_MAX = 17576;
}
    const 
{
    int L_tmpnam = 25;
}
}
else
{
    static assert(false);
}
}
}
}
}
    enum 
{
SEEK_SET,
SEEK_CUR,
SEEK_END,
}
    struct _iobuf
{
    align (1)
{
    version (Win32)
{
    char* _ptr;
    int _cnt;
    char* _base;
    int _flag;
    int _file;
    int _charbuf;
    int _bufsiz;
    int __tmpnum;
}
else
{
    version (linux)
{
    char* _read_ptr;
    char* _read_end;
    char* _read_base;
    char* _write_base;
    char* _write_ptr;
    char* _write_end;
    char* _buf_base;
    char* _buf_end;
    char* _save_base;
    char* _backup_base;
    char* _save_end;
    void* _markers;
    _iobuf* _chain;
    int _fileno;
    int _blksize;
    int _old_offset;
    ushort _cur_column;
    byte _vtable_offset;
    char[1] _shortbuf;
    void* _lock;
}
else
{
    version (darwin)
{
    ubyte* _p;
    int _r;
    int _w;
    short _flags;
    short _file;
    __sbuf _bf;
    int _lbfsize;
    int* function(void*) _close;
    int* function(void*, char*, int) _read;
    fpos_t* function(void*, fpos_t, int) _seek;
    int* function(void*, char*, int) _write;
    __sbuf _ub;
    __sFILEX* _extra;
    int _ur;
    ubyte[3] _ubuf;
    ubyte[1] _nbuf;
    __sbuf _lb;
    int _blksize;
    fpos_t _offset;
}
else
{
    version (freebsd)
{
    ubyte* _p;
    int _r;
    int _w;
    short _flags;
    short _file;
    __sbuf _bf;
    int _lbfsize;
    void* function() _cookie;
    int* function(void*) _close;
    int* function(void*, char*, int) _read;
    fpos_t* function(void*, fpos_t, int) _seek;
    int* function(void*, char*, int) _write;
    __sbuf _ub;
    __sFILEX* _extra;
    int _ur;
    ubyte[3] _ubuf;
    ubyte[1] _nbuf;
    __sbuf _lb;
    int _blksize;
    fpos_t _offset;
}
else
{
    version (solaris)
{
    ubyte* _next;
    ubyte* _endw;
    ubyte* _endr;
    ubyte* _endb;
    _iobuf* _push;
    ushort _flags;
    short _file;
    ubyte* _data;
    ptrdiff_t _size;
    ptrdiff_t _val;
}
else
{
    static assert(false);
}
}
}
}
}
}
}
    alias _iobuf FILE;
    enum 
{
_F_RDWR = 3,
_F_READ = 1,
_F_WRIT = 2,
_F_BUF = 4,
_F_LBUF = 8,
_F_ERR = 16,
_F_EOF = 32,
_F_BIN = 64,
_F_IN = 128,
_F_OUT = 256,
_F_TERM = 512,
}
}
version (Win32)
{
    enum 
{
_IOFBF = 0,
_IOREAD = 1,
_IOWRT = 2,
_IONBF = 4,
_IOMYBUF = 8,
_IOEOF = 16,
_IOERR = 32,
_IOLBF = 64,
_IOSTRG = 64,
_IORW = 128,
_IOTRAN = 256,
_IOAPP = 512,
}
    extern 
{
    extern (C) 
{
    void function() _fcloseallp;
}
}
    version (GNU)
{
    extern (C) 
{
    extern 
{
    FILE[_NFILE]* _imp___iob;
}
}
    FILE* stdin;
    FILE* stdout;
    FILE* stderr;
    FILE* stdaux;
    FILE* stdprn;
    static this();
}
else
{
    version (LDC)
{
    extern (C) 
{
    extern 
{
    FILE[_NFILE]* _imp___iob;
}
}
    FILE* stdin;
    FILE* stdout;
    FILE* stderr;
    FILE* stdaux;
    FILE* stdprn;
    static this();
}
else
{
    extern (C) 
{
    extern 
{
    FILE[_NFILE] _iob;
}
}
    FILE* stdin = &_iob[0];
    FILE* stdout = &_iob[1];
    FILE* stderr = &_iob[2];
    FILE* stdaux = &_iob[3];
    FILE* stdprn = &_iob[4];
}
}
}
else
{
    version (linux)
{
    enum 
{
_IOFBF = 0,
_IOLBF = 1,
_IONBF = 2,
}
    extern (C) 
{
    extern 
{
    FILE* stdin;
}
}
    extern (C) 
{
    extern 
{
    FILE* stdout;
}
}
    extern (C) 
{
    extern 
{
    FILE* stderr;
}
}
}
else
{
    version (darwin)
{
    extern (C) 
{
    extern 
{
    FILE* __stdinp;
}
}
    extern (C) 
{
    extern 
{
    FILE* __stdoutp;
}
}
    extern (C) 
{
    extern 
{
    FILE* __stderrp;
}
}
    FILE* stdin;
    FILE* stdout;
    FILE* stderr;
    static this();
}
else
{
    version (freebsd)
{
    extern (C) 
{
    extern 
{
    FILE[3] __sF;
}
}
    FILE* stdin = &__sF[0];
    FILE* stdout = &__sF[1];
    FILE* stderr = &__sF[2];
}
else
{
    version (solaris)
{
    extern (C) 
{
    extern 
{
    FILE[_NFILE] __iob;
}
}
    FILE* stdin = &__iob[0];
    FILE* stdout = &__iob[1];
    FILE* stderr = &__iob[2];
}
else
{
    static assert(false);
}
}
}
}
}
alias int fpos_t;
extern (C) 
{
    int remove(char* filename);
    int rename(char* from, char* to);
    FILE* tmpfile();
    char* tmpnam(char* s);
    int fclose(FILE* stream);
    int fflush(FILE* stream);
    FILE* fopen(char* filename, char* mode);
    FILE* freopen(char* filename, char* mode, FILE* stream);
    void setbuf(FILE* stream, char* buf);
    int setvbuf(FILE* stream, char* buf, int mode, size_t size);
    int fprintf(FILE* stream, char* format,...);
    int fscanf(FILE* stream, char* format,...);
    int sprintf(char* s, char* format,...);
    int sscanf(char* s, char* format,...);
    int vfprintf(FILE* stream, char* format, va_list arg);
    int vfscanf(FILE* stream, char* format, va_list arg);
    int vsprintf(char* s, char* format, va_list arg);
    int vsscanf(char* s, char* format, va_list arg);
    int vprintf(char* format, va_list arg);
    int vscanf(char* format, va_list arg);
    int printf(char* format,...);
    int scanf(char* format,...);
    int fgetc(FILE* stream);
    int fputc(int c, FILE* stream);
    char* fgets(char* s, int n, FILE* stream);
    int fputs(char* s, FILE* stream);
    char* gets(char* s);
    int puts(char* s);
}
extern (D) 
{
    int getchar()
{
return getc(stdin);
}
    int putchar(int c)
{
return putc(c,stdout);
}
    int getc(FILE* stream)
{
return fgetc(stream);
}
    int putc(int c, FILE* stream)
{
return fputc(c,stream);
}
}
extern (C) 
{
    int ungetc(int c, FILE* stream);
    size_t fread(void* ptr, size_t size, size_t nmemb, FILE* stream);
    size_t fwrite(void* ptr, size_t size, size_t nmemb, FILE* stream);
    int fgetpos(FILE* stream, fpos_t* pos);
    int fsetpos(FILE* stream, fpos_t* pos);
    int fseek(FILE* stream, c_long offset, int whence);
    c_long ftell(FILE* stream);
}
extern (C) 
{
    version (Win32)
{
    extern (D) 
{
    void rewind(FILE* stream)
{
fseek(stream,0L,SEEK_SET);
stream._flag &= ~_IOERR;
}
    void clearerr(FILE* stream)
{
stream._flag &= ~(_IOERR | _IOEOF);
}
    int feof(FILE* stream)
{
return stream._flag & _IOEOF;
}
    int ferror(FILE* stream)
{
return stream._flag & _IOERR;
}
}
    int _snprintf(char* s, size_t n, char* fmt,...);
    alias _snprintf snprintf;
    int _vsnprintf(char* s, size_t n, char* format, va_list arg);
    alias _vsnprintf vsnprintf;
}
else
{
    version (linux)
{
    void rewind(FILE* stream);
    void clearerr(FILE* stream);
    int feof(FILE* stream);
    int ferror(FILE* stream);
    int fileno(FILE*);
    int snprintf(char* s, size_t n, char* format,...);
    int vsnprintf(char* s, size_t n, char* format, va_list arg);
}
else
{
    version (darwin)
{
    void rewind(FILE*);
    void clearerr(FILE*);
    int feof(FILE*);
    int ferror(FILE*);
    int fileno(FILE*);
    int snprintf(char* s, size_t n, char* format,...);
    int vsnprintf(char* s, size_t n, char* format, va_list arg);
}
else
{
    version (freebsd)
{
    void rewind(FILE*);
    void clearerr(FILE*);
    int feof(FILE*);
    int ferror(FILE*);
    int fileno(FILE*);
    int snprintf(char* s, size_t n, char* format,...);
    int vsnprintf(char* s, size_t n, char* format, va_list arg);
}
else
{
    version (solaris)
{
    void rewind(FILE*);
    void clearerr(FILE*);
    int feof(FILE*);
    int ferror(FILE*);
    int fileno(FILE*);
    int snprintf(char* s, size_t n, char* format,...);
    int vsnprintf(char* s, size_t n, char* format, va_list arg);
}
else
{
    static assert(false);
}
}
}
}
}
    void perror(char* s);
    int fwprintf(FILE* stream, wchar_t* format,...);
    int fwscanf(FILE* stream, wchar_t* format,...);
    int swprintf(wchar_t* s, size_t n, wchar_t* format,...);
    int swscanf(wchar_t* s, wchar_t* format,...);
    int vfwprintf(FILE* stream, wchar_t* format, va_list arg);
    int vfwscanf(FILE* stream, wchar_t* format, va_list arg);
    int vswprintf(wchar_t* s, size_t n, wchar_t* format, va_list arg);
    int vswscanf(wchar_t* s, wchar_t* format, va_list arg);
    int vwprintf(wchar_t* format, va_list arg);
    int vwscanf(wchar_t* format, va_list arg);
    int wprintf(wchar_t* format,...);
    int wscanf(wchar_t* format,...);
    wint_t fgetwc(FILE* stream);
    wint_t fputwc(wchar_t c, FILE* stream);
    wchar_t* fgetws(wchar_t* s, int n, FILE* stream);
    int fputws(wchar_t* s, FILE* stream);
    extern (D) 
{
    wint_t getwchar()
{
return fgetwc(stdin);
}
    wint_t putwchar(wchar_t c)
{
return fputwc(c,stdout);
}
    wint_t getwc(FILE* stream)
{
return fgetwc(stream);
}
    wint_t putwc(wchar_t c, FILE* stream)
{
return fputwc(c,stream);
}
}
    wint_t ungetwc(wint_t c, FILE* stream);
    int fwide(FILE* stream, int mode);
}
