/src/core/stdc/stdio.d

http://github.com/AlexeyProkhin/druntime · D · 821 lines · 682 code · 101 blank · 38 comment · 26 complexity · bbd5e3a9e42b79b9070e13ba62074c53 MD5 · raw file

  1. /**
  2. * D header file for C99.
  3. *
  4. * Copyright: Copyright Sean Kelly 2005 - 2009.
  5. * License: <a href="http://www.boost.org/LICENSE_1_0.txt">Boost License 1.0</a>.
  6. * Authors: Sean Kelly,
  7. Alex Rønne Petersen
  8. * Standards: ISO/IEC 9899:1999 (E)
  9. */
  10. /* Copyright Sean Kelly 2005 - 2009.
  11. * Distributed under the Boost Software License, Version 1.0.
  12. * (See accompanying file LICENSE or copy at
  13. * http://www.boost.org/LICENSE_1_0.txt)
  14. */
  15. module core.stdc.stdio;
  16. private
  17. {
  18. import core.stdc.config;
  19. import core.stdc.stddef; // for size_t
  20. import core.stdc.stdarg; // for va_list
  21. version (FreeBSD)
  22. {
  23. import core.sys.posix.sys.types;
  24. }
  25. }
  26. extern (C):
  27. @system:
  28. nothrow:
  29. version( Win32 )
  30. {
  31. enum
  32. {
  33. BUFSIZ = 0x4000,
  34. EOF = -1,
  35. FOPEN_MAX = 20,
  36. FILENAME_MAX = 256, // 255 plus NULL
  37. TMP_MAX = 32767,
  38. SYS_OPEN = 20, // non-standard
  39. }
  40. enum int _NFILE = 60; // non-standard
  41. enum string _P_tmpdir = "\\"; // non-standard
  42. enum wstring _wP_tmpdir = "\\"; // non-standard
  43. enum int L_tmpnam = _P_tmpdir.length + 12;
  44. }
  45. else version( Win64 )
  46. {
  47. enum
  48. {
  49. BUFSIZ = 512,
  50. EOF = -1,
  51. FOPEN_MAX = 20,
  52. FILENAME_MAX = 260,
  53. TMP_MAX = 32767,
  54. _SYS_OPEN = 20, // non-standard
  55. }
  56. enum int _NFILE = 512; // non-standard
  57. enum string _P_tmpdir = "\\"; // non-standard
  58. enum wstring _wP_tmpdir = "\\"; // non-standard
  59. enum int L_tmpnam = _P_tmpdir.length + 12;
  60. }
  61. else version( linux )
  62. {
  63. enum
  64. {
  65. BUFSIZ = 8192,
  66. EOF = -1,
  67. FOPEN_MAX = 16,
  68. FILENAME_MAX = 4095,
  69. TMP_MAX = 238328,
  70. L_tmpnam = 20
  71. }
  72. }
  73. else version( OSX )
  74. {
  75. enum
  76. {
  77. BUFSIZ = 1024,
  78. EOF = -1,
  79. FOPEN_MAX = 20,
  80. FILENAME_MAX = 1024,
  81. TMP_MAX = 308915776,
  82. L_tmpnam = 1024,
  83. }
  84. private
  85. {
  86. struct __sbuf
  87. {
  88. ubyte* _base;
  89. int _size;
  90. }
  91. struct __sFILEX
  92. {
  93. }
  94. }
  95. }
  96. else version ( FreeBSD )
  97. {
  98. enum
  99. {
  100. BUFSIZ = 1024,
  101. EOF = -1,
  102. FOPEN_MAX = 20,
  103. FILENAME_MAX = 1024,
  104. TMP_MAX = 308915776,
  105. L_tmpnam = 1024
  106. }
  107. struct __sbuf
  108. {
  109. ubyte *_base;
  110. int _size;
  111. }
  112. alias _iobuf __sFILE;
  113. union __mbstate_t // <sys/_types.h>
  114. {
  115. char[128] _mbstate8;
  116. long _mbstateL;
  117. }
  118. }
  119. else version (Solaris)
  120. {
  121. enum
  122. {
  123. BUFSIZ = 1024,
  124. EOF = -1,
  125. FOPEN_MAX = _NFILE,
  126. FILENAME_MAX = 1024,
  127. TMP_MAX = 17576,
  128. L_tmpnam = 25,
  129. }
  130. version (X86)
  131. enum int _NFILE = 60;
  132. else
  133. enum int _NFILE = 20;
  134. }
  135. else
  136. {
  137. static assert( false, "Unsupported platform" );
  138. }
  139. enum
  140. {
  141. SEEK_SET,
  142. SEEK_CUR,
  143. SEEK_END
  144. }
  145. version( Win32 )
  146. {
  147. struct _iobuf
  148. {
  149. char* _ptr;
  150. int _cnt;
  151. char* _base;
  152. int _flag;
  153. int _file;
  154. int _charbuf;
  155. int _bufsiz;
  156. char* __tmpnum;
  157. }
  158. }
  159. else version( Win64 )
  160. {
  161. struct _iobuf
  162. {
  163. char* _ptr;
  164. int _cnt;
  165. char* _base;
  166. int _flag;
  167. int _file;
  168. int _charbuf;
  169. int _bufsiz;
  170. char* _tmpfname;
  171. }
  172. }
  173. else version( linux )
  174. {
  175. align(1) struct _iobuf
  176. {
  177. int _flags;
  178. char* _read_ptr;
  179. char* _read_end;
  180. char* _read_base;
  181. char* _write_base;
  182. char* _write_ptr;
  183. char* _write_end;
  184. char* _buf_base;
  185. char* _buf_end;
  186. char* _save_base;
  187. char* _backup_base;
  188. char* _save_end;
  189. void* _markers;
  190. _iobuf* _chain;
  191. int _fileno;
  192. int _blksize;
  193. int _old_offset;
  194. ushort _cur_column;
  195. byte _vtable_offset;
  196. char[1] _shortbuf;
  197. void* _lock;
  198. }
  199. }
  200. else version( OSX )
  201. {
  202. align (1) struct _iobuf
  203. {
  204. ubyte* _p;
  205. int _r;
  206. int _w;
  207. short _flags;
  208. short _file;
  209. __sbuf _bf;
  210. int _lbfsize;
  211. int* function(void*) _close;
  212. int* function(void*, char*, int) _read;
  213. fpos_t* function(void*, fpos_t, int) _seek;
  214. int* function(void*, char *, int) _write;
  215. __sbuf _ub;
  216. __sFILEX* _extra;
  217. int _ur;
  218. ubyte[3] _ubuf;
  219. ubyte[1] _nbuf;
  220. __sbuf _lb;
  221. int _blksize;
  222. fpos_t _offset;
  223. }
  224. }
  225. else version( FreeBSD )
  226. {
  227. align (1) struct _iobuf
  228. {
  229. ubyte* _p;
  230. int _r;
  231. int _w;
  232. short _flags;
  233. short _file;
  234. __sbuf _bf;
  235. int _lbfsize;
  236. void* _cookie;
  237. int function(void*) _close;
  238. int function(void*, char*, int) _read;
  239. fpos_t function(void*, fpos_t, int) _seek;
  240. int function(void*, in char*, int) _write;
  241. __sbuf _ub;
  242. ubyte* _up;
  243. int _ur;
  244. ubyte[3] _ubuf;
  245. ubyte[1] _nbuf;
  246. __sbuf _lb;
  247. int _blksize;
  248. fpos_t _offset;
  249. pthread_mutex_t _fl_mutex;
  250. pthread_t _fl_owner;
  251. int _fl_count;
  252. int _orientation;
  253. __mbstate_t _mbstate;
  254. }
  255. }
  256. else version (Solaris)
  257. {
  258. align (1) struct _iobuf
  259. {
  260. char* _ptr;
  261. int _cnt;
  262. char* _base;
  263. char _flag;
  264. char _magic;
  265. ushort __flags; // __orientation:2
  266. // __ionolock:1
  267. // __seekable:1
  268. // __extendedfd:1
  269. // __xf_nocheck:1
  270. // __filler:10
  271. }
  272. }
  273. else
  274. {
  275. static assert( false, "Unsupported platform" );
  276. }
  277. alias shared(_iobuf) FILE;
  278. enum
  279. {
  280. _F_RDWR = 0x0003, // non-standard
  281. _F_READ = 0x0001, // non-standard
  282. _F_WRIT = 0x0002, // non-standard
  283. _F_BUF = 0x0004, // non-standard
  284. _F_LBUF = 0x0008, // non-standard
  285. _F_ERR = 0x0010, // non-standard
  286. _F_EOF = 0x0020, // non-standard
  287. _F_BIN = 0x0040, // non-standard
  288. _F_IN = 0x0080, // non-standard
  289. _F_OUT = 0x0100, // non-standard
  290. _F_TERM = 0x0200, // non-standard
  291. }
  292. version( Win32 )
  293. {
  294. enum
  295. {
  296. _IOFBF = 0,
  297. _IOLBF = 0x40,
  298. _IONBF = 4,
  299. _IOREAD = 1, // non-standard
  300. _IOWRT = 2, // non-standard
  301. _IOMYBUF = 8, // non-standard
  302. _IOEOF = 0x10, // non-standard
  303. _IOERR = 0x20, // non-standard
  304. _IOSTRG = 0x40, // non-standard
  305. _IORW = 0x80, // non-standard
  306. _IOTRAN = 0x100, // non-standard
  307. _IOAPP = 0x200, // non-standard
  308. }
  309. extern shared void function() _fcloseallp;
  310. private extern shared FILE[_NFILE] _iob;
  311. shared stdin = &_iob[0];
  312. shared stdout = &_iob[1];
  313. shared stderr = &_iob[2];
  314. shared stdaux = &_iob[3];
  315. shared stdprn = &_iob[4];
  316. }
  317. else version( Win64 )
  318. {
  319. enum
  320. {
  321. _IOFBF = 0,
  322. _IOLBF = 0x40,
  323. _IONBF = 4,
  324. _IOREAD = 1, // non-standard
  325. _IOWRT = 2, // non-standard
  326. _IOMYBUF = 8, // non-standard
  327. _IOEOF = 0x10, // non-standard
  328. _IOERR = 0x20, // non-standard
  329. _IOSTRG = 0x40, // non-standard
  330. _IORW = 0x80, // non-standard
  331. _IOAPP = 0x200, // non-standard
  332. _IOAPPEND = 0x200, // non-standard
  333. }
  334. extern shared void function() _fcloseallp;
  335. private extern shared FILE[_NFILE] _iob;
  336. shared(FILE)* __iob_func();
  337. shared FILE* stdin; // = &__iob_func()[0];
  338. shared FILE* stdout; // = &__iob_func()[1];
  339. shared FILE* stderr; // = &__iob_func()[2];
  340. }
  341. else version( linux )
  342. {
  343. enum
  344. {
  345. _IOFBF = 0,
  346. _IOLBF = 1,
  347. _IONBF = 2,
  348. }
  349. extern shared FILE* stdin;
  350. extern shared FILE* stdout;
  351. extern shared FILE* stderr;
  352. }
  353. else version( OSX )
  354. {
  355. enum
  356. {
  357. _IOFBF = 0,
  358. _IOLBF = 1,
  359. _IONBF = 2,
  360. }
  361. private extern shared FILE* __stdinp;
  362. private extern shared FILE* __stdoutp;
  363. private extern shared FILE* __stderrp;
  364. alias __stdinp stdin;
  365. alias __stdoutp stdout;
  366. alias __stderrp stderr;
  367. }
  368. else version( FreeBSD )
  369. {
  370. enum
  371. {
  372. _IOFBF = 0,
  373. _IOLBF = 1,
  374. _IONBF = 2,
  375. }
  376. private extern shared FILE* __stdinp;
  377. private extern shared FILE* __stdoutp;
  378. private extern shared FILE* __stderrp;
  379. alias __stdinp stdin;
  380. alias __stdoutp stdout;
  381. alias __stderrp stderr;
  382. }
  383. else version (Solaris)
  384. {
  385. enum
  386. {
  387. _IOFBF = 0x00,
  388. _IOLBF = 0x40,
  389. _IONBF = 0x04,
  390. _IOEOF = 0x20,
  391. _IOERR = 0x40,
  392. _IOREAD = 0x01,
  393. _IOWRT = 0x02,
  394. _IORW = 0x80,
  395. _IOMYBUF = 0x08,
  396. }
  397. private extern shared FILE[_NFILE] __iob;
  398. shared stdin = &__iob[0];
  399. shared stdout = &__iob[1];
  400. shared stderr = &__iob[2];
  401. }
  402. else
  403. {
  404. static assert( false, "Unsupported platform" );
  405. }
  406. alias int fpos_t;
  407. int remove(in char* filename);
  408. int rename(in char* from, in char* to);
  409. @trusted FILE* tmpfile(); // No unsafe pointer manipulation.
  410. char* tmpnam(char* s);
  411. int fclose(FILE* stream);
  412. // No unsafe pointer manipulation.
  413. @trusted
  414. {
  415. int fflush(FILE* stream);
  416. }
  417. FILE* fopen(in char* filename, in char* mode);
  418. FILE* freopen(in char* filename, in char* mode, FILE* stream);
  419. void setbuf(FILE* stream, char* buf);
  420. int setvbuf(FILE* stream, char* buf, int mode, size_t size);
  421. version (MinGW)
  422. {
  423. // Prefer the MinGW versions over the MSVC ones, as the latter don't handle
  424. // reals at all.
  425. int __mingw_fprintf(FILE* stream, in char* format, ...);
  426. alias __mingw_fprintf fprintf;
  427. int __mingw_fscanf(FILE* stream, in char* format, ...);
  428. alias __mingw_fscanf fscanf;
  429. int __mingw_sprintf(char* s, in char* format, ...);
  430. alias __mingw_sprintf sprintf;
  431. int __mingw_sscanf(in char* s, in char* format, ...);
  432. alias __mingw_sscanf sscanf;
  433. int __mingw_vfprintf(FILE* stream, in char* format, va_list arg);
  434. alias __mingw_vfprintf vfprintf;
  435. int __mingw_vfscanf(FILE* stream, in char* format, va_list arg);
  436. alias __mingw_vfscanf vfscanf;
  437. int __mingw_vsprintf(char* s, in char* format, va_list arg);
  438. alias __mingw_vsprintf vsprintf;
  439. int __mingw_vsscanf(in char* s, in char* format, va_list arg);
  440. alias __mingw_vsscanf vsscanf;
  441. int __mingw_vprintf(in char* format, va_list arg);
  442. alias __mingw_vprintf vprintf;
  443. int __mingw_vscanf(in char* format, va_list arg);
  444. alias __mingw_vscanf vscanf;
  445. int __mingw_printf(in char* format, ...);
  446. alias __mingw_printf printf;
  447. int __mingw_scanf(in char* format, ...);
  448. alias __mingw_scanf scanf;
  449. }
  450. else
  451. {
  452. int fprintf(FILE* stream, in char* format, ...);
  453. int fscanf(FILE* stream, in char* format, ...);
  454. int sprintf(char* s, in char* format, ...);
  455. int sscanf(in char* s, in char* format, ...);
  456. int vfprintf(FILE* stream, in char* format, va_list arg);
  457. int vfscanf(FILE* stream, in char* format, va_list arg);
  458. int vsprintf(char* s, in char* format, va_list arg);
  459. int vsscanf(in char* s, in char* format, va_list arg);
  460. int vprintf(in char* format, va_list arg);
  461. int vscanf(in char* format, va_list arg);
  462. int printf(in char* format, ...);
  463. int scanf(in char* format, ...);
  464. }
  465. // No usafe pointer manipulation.
  466. @trusted
  467. {
  468. int fgetc(FILE* stream);
  469. int fputc(int c, FILE* stream);
  470. }
  471. char* fgets(char* s, int n, FILE* stream);
  472. int fputs(in char* s, FILE* stream);
  473. char* gets(char* s);
  474. int puts(in char* s);
  475. // No unsafe pointer manipulation.
  476. extern (D) @trusted
  477. {
  478. int getchar() { return getc(stdin); }
  479. int putchar(int c) { return putc(c,stdout); }
  480. int getc(FILE* stream) { return fgetc(stream); }
  481. int putc(int c, FILE* stream) { return fputc(c,stream); }
  482. }
  483. @trusted int ungetc(int c, FILE* stream); // No unsafe pointer manipulation.
  484. size_t fread(void* ptr, size_t size, size_t nmemb, FILE* stream);
  485. size_t fwrite(in void* ptr, size_t size, size_t nmemb, FILE* stream);
  486. // No unsafe pointer manipulation.
  487. @trusted
  488. {
  489. int fgetpos(FILE* stream, fpos_t * pos);
  490. int fsetpos(FILE* stream, in fpos_t* pos);
  491. int fseek(FILE* stream, c_long offset, int whence);
  492. c_long ftell(FILE* stream);
  493. }
  494. version( MinGW )
  495. {
  496. // No unsafe pointer manipulation.
  497. extern (D) @trusted
  498. {
  499. // TODO: Check if this is correct.
  500. void rewind(FILE* stream) { fseek(stream,0L,SEEK_SET); stream._flag&=~_IOERR; }
  501. pure void clearerr(FILE* stream) { stream._flag &= ~(_IOERR|_IOEOF); }
  502. pure int feof(FILE* stream) { return stream._flag&_IOEOF; }
  503. pure int ferror(FILE* stream) { return stream._flag&_IOERR; }
  504. }
  505. int __mingw_snprintf(char* s, size_t n, in char* fmt, ...);
  506. alias __mingw_snprintf _snprintf;
  507. alias __mingw_snprintf snprintf;
  508. int __mingw_vsnprintf(char* s, size_t n, in char* format, va_list arg);
  509. alias __mingw_vsnprintf _vsnprintf;
  510. alias __mingw_vsnprintf vsnprintf;
  511. }
  512. else version( Win32 )
  513. {
  514. // No unsafe pointer manipulation.
  515. extern (D) @trusted
  516. {
  517. void rewind(FILE* stream) { fseek(stream,0L,SEEK_SET); stream._flag&=~_IOERR; }
  518. pure void clearerr(FILE* stream) { stream._flag &= ~(_IOERR|_IOEOF); }
  519. pure int feof(FILE* stream) { return stream._flag&_IOEOF; }
  520. pure int ferror(FILE* stream) { return stream._flag&_IOERR; }
  521. }
  522. int _snprintf(char* s, size_t n, in char* fmt, ...);
  523. alias _snprintf snprintf;
  524. int _vsnprintf(char* s, size_t n, in char* format, va_list arg);
  525. alias _vsnprintf vsnprintf;
  526. }
  527. else version( Win64 )
  528. {
  529. // No unsafe pointer manipulation.
  530. extern (D) @trusted
  531. {
  532. void rewind(FILE* stream) { fseek(stream,0L,SEEK_SET); stream._flag&=~_IOERR; }
  533. pure void clearerr(FILE* stream) { stream._flag &= ~(_IOERR|_IOEOF); }
  534. pure int feof(FILE* stream) { return stream._flag&_IOEOF; }
  535. pure int ferror(FILE* stream) { return stream._flag&_IOERR; }
  536. pure int fileno(FILE* stream) { return stream._file; }
  537. }
  538. int _snprintf(char* s, size_t n, in char* fmt, ...);
  539. alias _snprintf snprintf;
  540. int _vsnprintf(char* s, size_t n, in char* format, va_list arg);
  541. alias _vsnprintf vsnprintf;
  542. int _filbuf(FILE *fp);
  543. int _flsbuf(int c, FILE *fp);
  544. int _fputc_nolock(int c, FILE *fp)
  545. {
  546. if (--fp._cnt >= 0)
  547. return *fp._ptr++ = cast(char)c;
  548. else
  549. return _flsbuf(c, fp);
  550. }
  551. int _fgetc_nolock(FILE *fp)
  552. {
  553. if (--fp._cnt >= 0)
  554. return *fp._ptr++;
  555. else
  556. return _filbuf(fp);
  557. }
  558. int _lock_file(FILE *fp);
  559. int _unlock_file(FILE *fp);
  560. }
  561. else version( linux )
  562. {
  563. // No unsafe pointer manipulation.
  564. @trusted
  565. {
  566. void rewind(FILE* stream);
  567. pure void clearerr(FILE* stream);
  568. pure int feof(FILE* stream);
  569. pure int ferror(FILE* stream);
  570. int fileno(FILE *);
  571. }
  572. int snprintf(char* s, size_t n, in char* format, ...);
  573. int vsnprintf(char* s, size_t n, in char* format, va_list arg);
  574. }
  575. else version( OSX )
  576. {
  577. // No unsafe pointer manipulation.
  578. @trusted
  579. {
  580. void rewind(FILE*);
  581. pure void clearerr(FILE*);
  582. pure int feof(FILE*);
  583. pure int ferror(FILE*);
  584. int fileno(FILE*);
  585. }
  586. int snprintf(char* s, size_t n, in char* format, ...);
  587. int vsnprintf(char* s, size_t n, in char* format, va_list arg);
  588. }
  589. else version( FreeBSD )
  590. {
  591. // No unsafe pointer manipulation.
  592. @trusted
  593. {
  594. void rewind(FILE*);
  595. pure void clearerr(FILE*);
  596. pure int feof(FILE*);
  597. pure int ferror(FILE*);
  598. int fileno(FILE*);
  599. }
  600. int snprintf(char* s, size_t n, in char* format, ...);
  601. int vsnprintf(char* s, size_t n, in char* format, va_list arg);
  602. }
  603. else version (Solaris)
  604. {
  605. // No unsafe pointer manipulation.
  606. @trusted
  607. {
  608. void rewind(FILE*);
  609. pure void clearerr(FILE*);
  610. pure int feof(FILE*);
  611. pure int ferror(FILE*);
  612. int fileno(FILE*);
  613. }
  614. int snprintf(char* s, size_t n, in char* format, ...);
  615. int vsnprintf(char* s, size_t n, in char* format, va_list arg);
  616. }
  617. else
  618. {
  619. static assert( false, "Unsupported platform" );
  620. }
  621. void perror(in char* s);
  622. version (DigitalMars) version (Win32)
  623. {
  624. import core.sys.windows.windows;
  625. enum
  626. {
  627. FHND_APPEND = 0x04,
  628. FHND_DEVICE = 0x08,
  629. FHND_TEXT = 0x10,
  630. FHND_BYTE = 0x20,
  631. FHND_WCHAR = 0x40,
  632. }
  633. private enum _MAX_SEMAPHORES = 10 + _NFILE;
  634. private enum _semIO = 3;
  635. private extern __gshared short _iSemLockCtrs[_MAX_SEMAPHORES];
  636. private extern __gshared int _iSemThreadIds[_MAX_SEMAPHORES];
  637. private extern __gshared int _iSemNestCount[_MAX_SEMAPHORES];
  638. private extern __gshared HANDLE[_NFILE] _osfhnd;
  639. private extern __gshared ubyte[_NFILE] __fhnd_info;
  640. private void _WaitSemaphore(int iSemaphore);
  641. private void _ReleaseSemaphore(int iSemaphore);
  642. // this is copied from semlock.h in DMC's runtime.
  643. private void LockSemaphore(uint num)
  644. {
  645. asm
  646. {
  647. mov EDX, num;
  648. lock;
  649. inc _iSemLockCtrs[EDX * 2];
  650. jz lsDone;
  651. push EDX;
  652. call _WaitSemaphore;
  653. add ESP, 4;
  654. }
  655. lsDone: {}
  656. }
  657. // this is copied from semlock.h in DMC's runtime.
  658. private void UnlockSemaphore(uint num)
  659. {
  660. asm
  661. {
  662. mov EDX, num;
  663. lock;
  664. dec _iSemLockCtrs[EDX * 2];
  665. js usDone;
  666. push EDX;
  667. call _ReleaseSemaphore;
  668. add ESP, 4;
  669. }
  670. usDone: {}
  671. }
  672. // This converts a HANDLE to a file descriptor in DMC's runtime
  673. int _handleToFD(HANDLE h, int flags)
  674. {
  675. LockSemaphore(_semIO);
  676. scope(exit) UnlockSemaphore(_semIO);
  677. foreach (fd; 0 .. _NFILE)
  678. {
  679. if (!_osfhnd[fd])
  680. {
  681. _osfhnd[fd] = h;
  682. __fhnd_info[fd] = cast(ubyte)flags;
  683. return fd;
  684. }
  685. }
  686. return -1;
  687. }
  688. HANDLE _fdToHandle(int fd)
  689. {
  690. // no semaphore is required, once inserted, a file descriptor
  691. // doesn't change.
  692. if (fd < 0 || fd >= _NFILE)
  693. return null;
  694. return _osfhnd[fd];
  695. }
  696. enum
  697. {
  698. O_RDONLY = 0x000,
  699. O_WRONLY = 0x001,
  700. O_RDWR = 0x002,
  701. O_APPEND = 0x008,
  702. O_CREAT = 0x100,
  703. O_TRUNC = 0x200,
  704. O_EXCL = 0x400,
  705. }
  706. enum
  707. {
  708. S_IREAD = 0x0100,
  709. S_IWRITE = 0x0080,
  710. }
  711. enum
  712. {
  713. STDIN_FILENO = 0,
  714. STDOUT_FILENO = 1,
  715. STDERR_FILENO = 2,
  716. }
  717. int open(const(char)* filename, int flags, ...);
  718. int close(int fd);
  719. FILE *fdopen(int fd, const(char)* flags);
  720. }