]> git.ipfire.org Git - thirdparty/gcc.git/blob - libphobos/libdruntime/core/sys/posix/sys/stat.d
projects / thirdparty / gcc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add D front-end, libphobos library, and D2 testsuite.
[thirdparty/gcc.git] / libphobos / libdruntime / core / sys / posix / sys / stat.d
1 /**
2 * D header file for POSIX.
3 *
4 * Copyright: Copyright Sean Kelly 2005 - 2009.
5 * License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
6 * Authors: Sean Kelly, Alex Rønne Petersen
7 * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
8 */
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.sys.posix.sys.stat;
16
17 private import core.sys.posix.config;
18 private import core.stdc.stdint;
19 private import core.sys.posix.time; // for timespec
20 public import core.sys.posix.sys.types; // for off_t, mode_t
21
22 version (OSX)
23 version = Darwin;
24 else version (iOS)
25 version = Darwin;
26 else version (TVOS)
27 version = Darwin;
28 else version (WatchOS)
29 version = Darwin;
30
31 version (Posix):
32 extern (C) nothrow @nogc:
33
34 //
35 // Required
36 //
37 /*
38 struct stat
39 {
40 dev_t st_dev;
41 ino_t st_ino;
42 mode_t st_mode;
43 nlink_t st_nlink;
44 uid_t st_uid;
45 gid_t st_gid;
46 off_t st_size;
47 time_t st_atime;
48 time_t st_mtime;
49 time_t st_ctime;
50 }
51
52 S_IRWXU
53 S_IRUSR
54 S_IWUSR
55 S_IXUSR
56 S_IRWXG
57 S_IRGRP
58 S_IWGRP
59 S_IXGRP
60 S_IRWXO
61 S_IROTH
62 S_IWOTH
63 S_IXOTH
64 S_ISUID
65 S_ISGID
66 S_ISVTX
67
68 S_ISBLK(m)
69 S_ISCHR(m)
70 S_ISDIR(m)
71 S_ISFIFO(m)
72 S_ISREG(m)
73 S_ISLNK(m)
74 S_ISSOCK(m)
75
76 S_TYPEISMQ(buf)
77 S_TYPEISSEM(buf)
78 S_TYPEISSHM(buf)
79
80 int chmod(in char*, mode_t);
81 int fchmod(int, mode_t);
82 int fstat(int, stat*);
83 int lstat(in char*, stat*);
84 int mkdir(in char*, mode_t);
85 int mkfifo(in char*, mode_t);
86 int stat(in char*, stat*);
87 mode_t umask(mode_t);
88 */
89
90 version (CRuntime_Glibc)
91 {
92 version (X86)
93 {
94 struct stat_t
95 {
96 dev_t st_dev;
97 ushort __pad1;
98 static if (!__USE_FILE_OFFSET64)
99 {
100 ino_t st_ino;
101 }
102 else
103 {
104 uint __st_ino;
105 }
106 mode_t st_mode;
107 nlink_t st_nlink;
108 uid_t st_uid;
109 gid_t st_gid;
110 dev_t st_rdev;
111 ushort __pad2;
112 off_t st_size;
113 blksize_t st_blksize;
114 blkcnt_t st_blocks;
115 static if (__USE_MISC || __USE_XOPEN2K8)
116 {
117 timespec st_atim;
118 timespec st_mtim;
119 timespec st_ctim;
120 extern(D)
121 {
122 @property ref time_t st_atime() { return st_atim.tv_sec; }
123 @property ref time_t st_mtime() { return st_mtim.tv_sec; }
124 @property ref time_t st_ctime() { return st_ctim.tv_sec; }
125 }
126 }
127 else
128 {
129 time_t st_atime;
130 ulong_t st_atimensec;
131 time_t st_mtime;
132 ulong_t st_mtimensec;
133 time_t st_ctime;
134 ulong_t st_ctimensec;
135 }
136 static if (__USE_FILE_OFFSET64)
137 {
138 ino_t st_ino;
139 }
140 else
141 {
142 c_ulong __unused4;
143 c_ulong __unused5;
144 }
145 }
146 }
147 else version (X86_64)
148 {
149 struct stat_t
150 {
151 dev_t st_dev;
152 ino_t st_ino;
153 nlink_t st_nlink;
154 mode_t st_mode;
155 uid_t st_uid;
156 gid_t st_gid;
157 uint __pad0;
158 dev_t st_rdev;
159 off_t st_size;
160 blksize_t st_blksize;
161 blkcnt_t st_blocks;
162 static if (__USE_MISC || __USE_XOPEN2K8)
163 {
164 timespec st_atim;
165 timespec st_mtim;
166 timespec st_ctim;
167 extern(D)
168 {
169 @property ref time_t st_atime() { return st_atim.tv_sec; }
170 @property ref time_t st_mtime() { return st_mtim.tv_sec; }
171 @property ref time_t st_ctime() { return st_ctim.tv_sec; }
172 }
173 }
174 else
175 {
176 time_t st_atime;
177 ulong_t st_atimensec;
178 time_t st_mtime;
179 ulong_t st_mtimensec;
180 time_t st_ctime;
181 ulong_t st_ctimensec;
182 }
183 slong_t[3] __unused;
184 }
185 }
186 else version (MIPS_O32)
187 {
188 struct stat_t
189 {
190 c_ulong st_dev;
191 c_long[3] st_pad1;
192 ino_t st_ino;
193 mode_t st_mode;
194 nlink_t st_nlink;
195 uid_t st_uid;
196 gid_t st_gid;
197 c_ulong st_rdev;
198 static if (!__USE_FILE_OFFSET64)
199 {
200 c_long[2] st_pad2;
201 off_t st_size;
202 c_long st_pad3;
203 }
204 else
205 {
206 c_long[3] st_pad2;
207 off_t st_size;
208 }
209 static if (__USE_MISC || __USE_XOPEN2K8)
210 {
211 timespec st_atim;
212 timespec st_mtim;
213 timespec st_ctim;
214 extern(D)
215 {
216 @property ref time_t st_atime() { return st_atim.tv_sec; }
217 @property ref time_t st_mtime() { return st_mtim.tv_sec; }
218 @property ref time_t st_ctime() { return st_ctim.tv_sec; }
219 }
220 }
221 else
222 {
223 time_t st_atime;
224 c_ulong st_atimensec;
225 time_t st_mtime;
226 c_ulong st_mtimensec;
227 time_t st_ctime;
228 c_ulong st_ctimensec;
229 }
230 blksize_t st_blksize;
231 static if (!__USE_FILE_OFFSET64)
232 {
233 blkcnt_t st_blocks;
234 }
235 else
236 {
237 c_long st_pad4;
238 blkcnt_t st_blocks;
239 }
240 c_long[14] st_pad5;
241 }
242 }
243 else version (MIPS64)
244 {
245 struct stat_t
246 {
247 c_ulong st_dev;
248 int[3] st_pad1;
249 static if (!__USE_FILE_OFFSET64)
250 {
251 ino_t st_ino;
252 }
253 else
254 {
255 c_ulong st_ino;
256 }
257 mode_t st_mode;
258 nlink_t st_nlink;
259 uid_t st_uid;
260 gid_t st_gid;
261 c_ulong st_rdev;
262 static if (!__USE_FILE_OFFSET64)
263 {
264 uint[2] st_pad2;
265 off_t st_size;
266 int st_pad3;
267 }
268 else
269 {
270 c_long[3] st_pad2;
271 c_long st_size;
272 }
273 static if (__USE_MISC || __USE_XOPEN2K8)
274 {
275 timespec st_atim;
276 timespec st_mtim;
277 timespec st_ctim;
278 extern(D)
279 {
280 @property ref time_t st_atime() { return st_atim.tv_sec; }
281 @property ref time_t st_mtime() { return st_mtim.tv_sec; }
282 @property ref time_t st_ctime() { return st_ctim.tv_sec; }
283 }
284 }
285 else
286 {
287 time_t st_atime;
288 c_ulong st_atimensec;
289 time_t st_mtime;
290 c_ulong st_mtimensec;
291 time_t st_ctime;
292 c_ulong st_ctimensec;
293 }
294 blksize_t st_blksize;
295 uint st_pad4;
296 static if (!__USE_FILE_OFFSET64)
297 {
298 blkcnt_t st_blocks;
299 }
300 else
301 {
302 c_long st_blocks;
303 }
304 c_long[14] st_pad5;
305 }
306 }
307 else version (PPC)
308 {
309 struct stat_t
310 {
311 c_ulong st_dev;
312 ino_t st_ino;
313 mode_t st_mode;
314 nlink_t st_nlink;
315 uid_t st_uid;
316 gid_t st_gid;
317 c_ulong st_rdev;
318 off_t st_size;
319 c_ulong st_blksize;
320 c_ulong st_blocks;
321 c_ulong st_atime;
322 c_ulong st_atime_nsec;
323 c_ulong st_mtime;
324 c_ulong st_mtime_nsec;
325 c_ulong st_ctime;
326 c_ulong st_ctime_nsec;
327 c_ulong __unused4;
328 c_ulong __unused5;
329 }
330 }
331 else version (PPC64)
332 {
333 struct stat_t
334 {
335 c_ulong st_dev;
336 ino_t st_ino;
337 nlink_t st_nlink;
338 mode_t st_mode;
339 uid_t st_uid;
340 gid_t st_gid;
341 c_ulong st_rdev;
342 off_t st_size;
343 c_ulong st_blksize;
344 c_ulong st_blocks;
345 c_ulong st_atime;
346 c_ulong st_atime_nsec;
347 c_ulong st_mtime;
348 c_ulong st_mtime_nsec;
349 c_ulong st_ctime;
350 c_ulong st_ctime_nsec;
351 c_ulong __unused4;
352 c_ulong __unused5;
353 c_ulong __unused6;
354 }
355 }
356 else version (ARM)
357 {
358 private
359 {
360 alias __dev_t = ulong;
361 alias __ino_t = c_ulong;
362 alias __ino64_t = ulong;
363 alias __mode_t = uint;
364 alias __nlink_t = size_t;
365 alias __uid_t = uint;
366 alias __gid_t = uint;
367 alias __off_t = c_long;
368 alias __off64_t = long;
369 alias __blksize_t = c_long;
370 alias __blkcnt_t = c_long;
371 alias __blkcnt64_t = long;
372 alias __timespec = timespec;
373 alias __time_t = time_t;
374 }
375 struct stat_t
376 {
377 __dev_t st_dev;
378 ushort __pad1;
379
380 static if (!__USE_FILE_OFFSET64)
381 {
382 __ino_t st_ino;
383 }
384 else
385 {
386 __ino_t __st_ino;
387 }
388 __mode_t st_mode;
389 __nlink_t st_nlink;
390 __uid_t st_uid;
391 __gid_t st_gid;
392 __dev_t st_rdev;
393 ushort __pad2;
394
395 static if (!__USE_FILE_OFFSET64)
396 {
397 __off_t st_size;
398 }
399 else
400 {
401 __off64_t st_size;
402 }
403 __blksize_t st_blksize;
404
405 static if (!__USE_FILE_OFFSET64)
406 {
407 __blkcnt_t st_blocks;
408 }
409 else
410 {
411 __blkcnt64_t st_blocks;
412 }
413
414 static if ( __USE_MISC || __USE_XOPEN2K8)
415 {
416 __timespec st_atim;
417 __timespec st_mtim;
418 __timespec st_ctim;
419 extern(D)
420 {
421 @property ref time_t st_atime() { return st_atim.tv_sec; }
422 @property ref time_t st_mtime() { return st_mtim.tv_sec; }
423 @property ref time_t st_ctime() { return st_ctim.tv_sec; }
424 }
425 }
426 else
427 {
428 __time_t st_atime;
429 c_ulong st_atimensec;
430 __time_t st_mtime;
431 c_ulong st_mtimensec;
432 __time_t st_ctime;
433 c_ulong st_ctimensec;
434 }
435
436 static if (!__USE_FILE_OFFSET64)
437 {
438 c_ulong __unused4;
439 c_ulong __unused5;
440 }
441 else
442 {
443 __ino64_t st_ino;
444 }
445 }
446 static if (__USE_FILE_OFFSET64)
447 static assert(stat_t.sizeof == 104);
448 else
449 static assert(stat_t.sizeof == 88);
450 }
451 else version (AArch64)
452 {
453 private
454 {
455 alias __dev_t = ulong;
456 alias __ino_t = c_ulong;
457 alias __ino64_t = ulong;
458 alias __mode_t = uint;
459 alias __nlink_t = uint;
460 alias __uid_t = uint;
461 alias __gid_t = uint;
462 alias __off_t = c_long;
463 alias __off64_t = long;
464 alias __blksize_t = int;
465 alias __blkcnt_t = c_long;
466 alias __blkcnt64_t = long;
467 alias __timespec = timespec;
468 alias __time_t = time_t;
469 }
470 struct stat_t
471 {
472 __dev_t st_dev;
473
474 static if (!__USE_FILE_OFFSET64)
475 {
476 __ino_t st_ino;
477 }
478 else
479 {
480 __ino64_t st_ino;
481 }
482 __mode_t st_mode;
483 __nlink_t st_nlink;
484 __uid_t st_uid;
485 __gid_t st_gid;
486 __dev_t st_rdev;
487 __dev_t __pad1;
488
489 static if (!__USE_FILE_OFFSET64)
490 {
491 __off_t st_size;
492 }
493 else
494 {
495 __off64_t st_size;
496 }
497 __blksize_t st_blksize;
498 int __pad2;
499
500 static if (!__USE_FILE_OFFSET64)
501 {
502 __blkcnt_t st_blocks;
503 }
504 else
505 {
506 __blkcnt64_t st_blocks;
507 }
508
509 static if (__USE_MISC)
510 {
511 __timespec st_atim;
512 __timespec st_mtim;
513 __timespec st_ctim;
514 extern(D)
515 {
516 @property ref time_t st_atime() { return st_atim.tv_sec; }
517 @property ref time_t st_mtime() { return st_mtim.tv_sec; }
518 @property ref time_t st_ctime() { return st_ctim.tv_sec; }
519 }
520 }
521 else
522 {
523 __time_t st_atime;
524 c_ulong st_atimensec;
525 __time_t st_mtime;
526 c_ulong st_mtimensec;
527 __time_t st_ctime;
528 c_ulong st_ctimensec;
529 }
530 int[2] __unused;
531 }
532 static if (__USE_FILE_OFFSET64)
533 static assert(stat_t.sizeof == 128);
534 else
535 static assert(stat_t.sizeof == 128);
536 }
537 else version (SPARC64)
538 {
539 private
540 {
541 alias __dev_t = ulong;
542 alias __ino_t = c_ulong;
543 alias __ino64_t = ulong;
544 alias __mode_t = uint;
545 alias __nlink_t = uint;
546 alias __uid_t = uint;
547 alias __gid_t = uint;
548 alias __off_t = c_long;
549 alias __off64_t = long;
550 alias __blksize_t = c_long;
551 alias __blkcnt_t = c_long;
552 alias __blkcnt64_t = long;
553 alias __timespec = timespec;
554 alias __time_t = time_t;
555 }
556 struct stat_t
557 {
558 __dev_t st_dev;
559 ushort __pad1;
560 __ino_t st_ino;
561 __mode_t st_mode;
562 __nlink_t st_nlink;
563 __uid_t st_uid;
564 __gid_t st_gid;
565 __dev_t st_rdev;
566 ushort __pad2;
567
568 static if (!__USE_FILE_OFFSET64)
569 {
570 __off_t st_size;
571 }
572 else
573 {
574 __off64_t st_size;
575 }
576 __blksize_t st_blksize;
577
578 static if (!__USE_FILE_OFFSET64)
579 {
580 __blkcnt_t st_blocks;
581 }
582 else
583 {
584 __blkcnt64_t st_blocks;
585 }
586
587 static if (__USE_XOPEN2K8)
588 {
589 __timespec st_atim;
590 __timespec st_mtim;
591 __timespec st_ctim;
592 extern(D)
593 {
594 @property ref time_t st_atime() { return st_atim.tv_sec; }
595 @property ref time_t st_mtime() { return st_mtim.tv_sec; }
596 @property ref time_t st_ctime() { return st_ctim.tv_sec; }
597 }
598 }
599 else
600 {
601 __time_t st_atime;
602 c_ulong st_atimensec;
603 __time_t st_mtime;
604 c_ulong st_mtimensec;
605 __time_t st_ctime;
606 c_ulong st_ctimensec;
607 }
608
609 c_ulong __unused4;
610 c_ulong __unused5;
611 }
612 static assert(stat_t.sizeof == 144);
613 }
614 else version (SystemZ)
615 {
616 private
617 {
618 alias __dev_t = ulong;
619 alias __ino_t = c_ulong;
620 alias __ino64_t = ulong;
621 alias __mode_t = uint;
622 alias __nlink_t = uint;
623 alias __uid_t = uint;
624 alias __gid_t = uint;
625 alias __off_t = c_long;
626 alias __off64_t = long;
627 alias __blksize_t = int;
628 alias __blkcnt_t = c_long;
629 alias __blkcnt64_t = long;
630 alias __timespec = timespec;
631 alias __time_t = time_t;
632 }
633 struct stat_t
634 {
635 __dev_t st_dev;
636 __ino_t st_ino;
637 __nlink_t st_nlink;
638 __mode_t st_mode;
639 __uid_t st_uid;
640 __gid_t st_gid;
641 int __glibc_reserved0;
642 __dev_t st_rdev;
643 __off_t st_size;
644 static if (__USE_XOPEN2K8)
645 {
646 __timespec st_atim;
647 __timespec st_mtim;
648 __timespec st_ctim;
649 extern(D)
650 {
651 @property ref time_t st_atime() { return st_atim.tv_sec; }
652 @property ref time_t st_mtime() { return st_mtim.tv_sec; }
653 @property ref time_t st_ctime() { return st_ctim.tv_sec; }
654 }
655 }
656 else
657 {
658 __time_t st_atime;
659 c_ulong st_atimensec;
660 __time_t st_mtime;
661 c_ulong st_mtimensec;
662 __time_t st_ctime;
663 c_ulong st_ctimensec;
664 }
665 __blksize_t st_blksize;
666 __blkcnt_t st_blocks;
667 c_long[3] __glibc_reserved;
668 }
669 static if (__USE_XOPEN2K8)
670 static assert(stat_t.sizeof == 144);
671 else
672 static assert(stat_t.sizeof == 144);
673 }
674 else
675 static assert(0, "unimplemented");
676
677 enum S_IRUSR = 0x100; // octal 0400
678 enum S_IWUSR = 0x080; // octal 0200
679 enum S_IXUSR = 0x040; // octal 0100
680 enum S_IRWXU = S_IRUSR | S_IWUSR | S_IXUSR;
681
682 enum S_IRGRP = S_IRUSR >> 3;
683 enum S_IWGRP = S_IWUSR >> 3;
684 enum S_IXGRP = S_IXUSR >> 3;
685 enum S_IRWXG = S_IRWXU >> 3;
686
687 enum S_IROTH = S_IRGRP >> 3;
688 enum S_IWOTH = S_IWGRP >> 3;
689 enum S_IXOTH = S_IXGRP >> 3;
690 enum S_IRWXO = S_IRWXG >> 3;
691
692 enum S_ISUID = 0x800; // octal 04000
693 enum S_ISGID = 0x400; // octal 02000
694 enum S_ISVTX = 0x200; // octal 01000
695
696 private
697 {
698 extern (D) bool S_ISTYPE( mode_t mode, uint mask )
699 {
700 return ( mode & S_IFMT ) == mask;
701 }
702 }
703
704 extern (D) bool S_ISBLK( mode_t mode ) { return S_ISTYPE( mode, S_IFBLK ); }
705 extern (D) bool S_ISCHR( mode_t mode ) { return S_ISTYPE( mode, S_IFCHR ); }
706 extern (D) bool S_ISDIR( mode_t mode ) { return S_ISTYPE( mode, S_IFDIR ); }
707 extern (D) bool S_ISFIFO( mode_t mode ) { return S_ISTYPE( mode, S_IFIFO ); }
708 extern (D) bool S_ISREG( mode_t mode ) { return S_ISTYPE( mode, S_IFREG ); }
709 extern (D) bool S_ISLNK( mode_t mode ) { return S_ISTYPE( mode, S_IFLNK ); }
710 extern (D) bool S_ISSOCK( mode_t mode ) { return S_ISTYPE( mode, S_IFSOCK ); }
711
712 static if ( true /*__USE_POSIX199309*/ )
713 {
714 extern bool S_TYPEISMQ( stat_t* buf ) { return false; }
715 extern bool S_TYPEISSEM( stat_t* buf ) { return false; }
716 extern bool S_TYPEISSHM( stat_t* buf ) { return false; }
717 }
718
719 enum UTIME_NOW = 0x3fffffff;
720 enum UTIME_OMIT = 0x3ffffffe;
721
722 int utimensat(int dirfd, const char *pathname,
723 ref const(timespec)[2] times, int flags);
724 int futimens(int fd, ref const(timespec)[2] times);
725 }
726 else version (Darwin)
727 {
728 // _DARWIN_FEATURE_64_BIT_INODE stat is default for Mac OSX >10.5 and is
729 // only meaningful type for other OS X/Darwin variants (e.g. iOS).
730 // man stat(2) gives details.
731 struct stat_t
732 {
733 dev_t st_dev;
734 mode_t st_mode;
735 nlink_t st_nlink;
736 ino_t st_ino;
737 uid_t st_uid;
738 gid_t st_gid;
739 dev_t st_rdev;
740 union
741 {
742 struct
743 {
744 timespec st_atimespec;
745 timespec st_mtimespec;
746 timespec st_ctimespec;
747 timespec st_birthtimespec;
748 }
749 struct
750 {
751 time_t st_atime;
752 c_long st_atimensec;
753 time_t st_mtime;
754 c_long st_mtimensec;
755 time_t st_ctime;
756 c_long st_ctimensec;
757 time_t st_birthtime;
758 c_long st_birthtimensec;
759 }
760 }
761 off_t st_size;
762 blkcnt_t st_blocks;
763 blksize_t st_blksize;
764 uint st_flags;
765 uint st_gen;
766 int st_lspare;
767 long[2] st_qspare;
768 }
769
770 enum S_IRUSR = 0x100; // octal 0400
771 enum S_IWUSR = 0x080; // octal 0200
772 enum S_IXUSR = 0x040; // octal 0100
773 enum S_IRWXU = S_IRUSR | S_IWUSR | S_IXUSR;
774
775 enum S_IRGRP = S_IRUSR >> 3;
776 enum S_IWGRP = S_IWUSR >> 3;
777 enum S_IXGRP = S_IXUSR >> 3;
778 enum S_IRWXG = S_IRWXU >> 3;
779
780 enum S_IROTH = S_IRGRP >> 3;
781 enum S_IWOTH = S_IWGRP >> 3;
782 enum S_IXOTH = S_IXGRP >> 3;
783 enum S_IRWXO = S_IRWXG >> 3;
784
785 enum S_ISUID = 0x800; // octal 04000
786 enum S_ISGID = 0x400; // octal 02000
787 enum S_ISVTX = 0x200; // octal 01000
788
789 private
790 {
791 extern (D) bool S_ISTYPE( mode_t mode, uint mask )
792 {
793 return ( mode & S_IFMT ) == mask;
794 }
795 }
796
797 extern (D) bool S_ISBLK( mode_t mode ) { return S_ISTYPE( mode, S_IFBLK ); }
798 extern (D) bool S_ISCHR( mode_t mode ) { return S_ISTYPE( mode, S_IFCHR ); }
799 extern (D) bool S_ISDIR( mode_t mode ) { return S_ISTYPE( mode, S_IFDIR ); }
800 extern (D) bool S_ISFIFO( mode_t mode ) { return S_ISTYPE( mode, S_IFIFO ); }
801 extern (D) bool S_ISREG( mode_t mode ) { return S_ISTYPE( mode, S_IFREG ); }
802 extern (D) bool S_ISLNK( mode_t mode ) { return S_ISTYPE( mode, S_IFLNK ); }
803 extern (D) bool S_ISSOCK( mode_t mode ) { return S_ISTYPE( mode, S_IFSOCK ); }
804 }
805 else version (FreeBSD)
806 {
807 // https://github.com/freebsd/freebsd/blob/master/sys/sys/stat.h
808
809 struct stat_t
810 {
811 dev_t st_dev;
812 ino_t st_ino;
813 mode_t st_mode;
814 nlink_t st_nlink;
815 uid_t st_uid;
816 gid_t st_gid;
817 dev_t st_rdev;
818
819 time_t st_atime;
820 c_long __st_atimensec;
821 time_t st_mtime;
822 c_long __st_mtimensec;
823 time_t st_ctime;
824 c_long __st_ctimensec;
825
826 off_t st_size;
827 blkcnt_t st_blocks;
828 blksize_t st_blksize;
829 fflags_t st_flags;
830 uint st_gen;
831 int st_lspare;
832
833 time_t st_birthtime;
834 c_long st_birthtimensec;
835
836 ubyte[16 - timespec.sizeof] padding;
837 }
838
839 enum S_IRUSR = 0x100; // octal 0000400
840 enum S_IWUSR = 0x080; // octal 0000200
841 enum S_IXUSR = 0x040; // octal 0000100
842 enum S_IRWXU = 0x1C0; // octal 0000700
843
844 enum S_IRGRP = 0x020; // octal 0000040
845 enum S_IWGRP = 0x010; // octal 0000020
846 enum S_IXGRP = 0x008; // octal 0000010
847 enum S_IRWXG = 0x038; // octal 0000070
848
849 enum S_IROTH = 0x4; // 0000004
850 enum S_IWOTH = 0x2; // 0000002
851 enum S_IXOTH = 0x1; // 0000001
852 enum S_IRWXO = 0x7; // 0000007
853
854 enum S_ISUID = 0x800; // octal 0004000
855 enum S_ISGID = 0x400; // octal 0002000
856 enum S_ISVTX = 0x200; // octal 0001000
857
858 private
859 {
860 extern (D) bool S_ISTYPE( mode_t mode, uint mask )
861 {
862 return ( mode & S_IFMT ) == mask;
863 }
864 }
865
866 extern (D) bool S_ISBLK( mode_t mode ) { return S_ISTYPE( mode, S_IFBLK ); }
867 extern (D) bool S_ISCHR( mode_t mode ) { return S_ISTYPE( mode, S_IFCHR ); }
868 extern (D) bool S_ISDIR( mode_t mode ) { return S_ISTYPE( mode, S_IFDIR ); }
869 extern (D) bool S_ISFIFO( mode_t mode ) { return S_ISTYPE( mode, S_IFIFO ); }
870 extern (D) bool S_ISREG( mode_t mode ) { return S_ISTYPE( mode, S_IFREG ); }
871 extern (D) bool S_ISLNK( mode_t mode ) { return S_ISTYPE( mode, S_IFLNK ); }
872 extern (D) bool S_ISSOCK( mode_t mode ) { return S_ISTYPE( mode, S_IFSOCK ); }
873
874 enum UTIME_NOW = -1;
875 enum UTIME_OMIT = -2;
876
877 // Since FreeBSD 11:
878 version (none)
879 {
880 int utimensat(int dirfd, const char *pathname,
881 ref const(timespec)[2] times, int flags);
882 int futimens(int fd, ref const(timespec)[2] times);
883 }
884 }
885 else version (NetBSD)
886 {
887 struct stat_t
888 {
889 dev_t st_dev; /* inode's device */
890 mode_t st_mode; /* inode protection mode */
891 ino_t st_ino; /* inode's number */
892 nlink_t st_nlink; /* number of hard links */
893 uid_t st_uid; /* user ID of the file's owner */
894 gid_t st_gid; /* group ID of the file's group */
895 dev_t st_rdev; /* device type */
896 time_t st_atime; /* time of last access */
897 long st_atimensec; /* nsec of last access */
898 time_t st_mtime; /* time of last data modification */
899 long st_mtimensec; /* nsec of last data modification */
900 time_t st_ctime; /* time of last file status change */
901 long st_ctimensec; /* nsec of last file status change */
902 time_t st_birthtime; /* time of creation */
903 long st_birthtimensec; /* nsec of time of creation */
904 off_t st_size; /* file size, in bytes */
905 blkcnt_t st_blocks; /* blocks allocated for file */
906 blksize_t st_blksize; /* optimal blocksize for I/O */
907 uint32_t st_flags; /* user defined flags for file */
908 uint32_t st_gen; /* file generation number */
909 uint32_t[2] st_spare;
910 }
911
912 enum S_IRUSR = 0x100; // octal 0000400
913 enum S_IWUSR = 0x080; // octal 0000200
914 enum S_IXUSR = 0x040; // octal 0000100
915 enum S_IRWXU = 0x1C0; // octal 0000700
916
917 enum S_IRGRP = 0x020; // octal 0000040
918 enum S_IWGRP = 0x010; // octal 0000020
919 enum S_IXGRP = 0x008; // octal 0000010
920 enum S_IRWXG = 0x038; // octal 0000070
921
922 enum S_IROTH = 0x4; // 0000004
923 enum S_IWOTH = 0x2; // 0000002
924 enum S_IXOTH = 0x1; // 0000001
925 enum S_IRWXO = 0x7; // 0000007
926
927 enum S_ISUID = 0x800; // octal 0004000
928 enum S_ISGID = 0x400; // octal 0002000
929 enum S_ISVTX = 0x200; // octal 0001000
930
931 private
932 {
933 extern (D) bool S_ISTYPE( mode_t mode, uint mask )
934 {
935 return ( mode & S_IFMT ) == mask;
936 }
937 }
938
939 extern (D) bool S_ISBLK( mode_t mode ) { return S_ISTYPE( mode, S_IFBLK ); }
940 extern (D) bool S_ISCHR( mode_t mode ) { return S_ISTYPE( mode, S_IFCHR ); }
941 extern (D) bool S_ISDIR( mode_t mode ) { return S_ISTYPE( mode, S_IFDIR ); }
942 extern (D) bool S_ISFIFO( mode_t mode ) { return S_ISTYPE( mode, S_IFIFO ); }
943 extern (D) bool S_ISREG( mode_t mode ) { return S_ISTYPE( mode, S_IFREG ); }
944 extern (D) bool S_ISLNK( mode_t mode ) { return S_ISTYPE( mode, S_IFLNK ); }
945 extern (D) bool S_ISSOCK( mode_t mode ) { return S_ISTYPE( mode, S_IFSOCK ); }
946 }
947 else version (DragonFlyBSD)
948 {
949 struct stat_t {
950 ino_t st_ino; /* inode's number */
951 nlink_t st_nlink; /* number of hard links */
952 dev_t st_dev; /* inode's device */
953 mode_t st_mode; /* inode protection mode */
954 uint16_t st_padding1;
955 uid_t st_uid; /* user ID of the file's owner */
956 gid_t st_gid; /* group ID of the file's group */
957 dev_t st_rdev; /* device type */
958 time_t st_atime;
959 c_long __st_atimensec;
960 time_t st_mtime;
961 c_long __st_mtimensec;
962 time_t st_ctime;
963 c_long __st_ctimensec;
964 off_t st_size; /* file size, in bytes */
965 int64_t st_blocks; /* blocks allocated for file */
966 uint32_t st_blksize; /* optimal blocksize for I/O */
967 uint32_t st_flags; /* user defined flags for file */
968 uint32_t st_gen; /* file generation number */
969 int32_t st_lspare;
970 int64_t st_qspare1; /* was recursive change detect */
971 int64_t st_qspare2;
972 };
973
974 enum S_IRUSR = 0x100; // octal 0000400
975 enum S_IWUSR = 0x080; // octal 0000200
976 enum S_IXUSR = 0x040; // octal 0000100
977 enum S_IRWXU = 0x1C0; // octal 0000700
978
979 enum S_IRGRP = 0x020; // octal 0000040
980 enum S_IWGRP = 0x010; // octal 0000020
981 enum S_IXGRP = 0x008; // octal 0000010
982 enum S_IRWXG = 0x038; // octal 0000070
983
984 enum S_IROTH = 0x4; // 0000004
985 enum S_IWOTH = 0x2; // 0000002
986 enum S_IXOTH = 0x1; // 0000001
987 enum S_IRWXO = 0x7; // 0000007
988
989 enum S_ISUID = 0x800; // octal 0004000
990 enum S_ISGID = 0x400; // octal 0002000
991 enum S_ISVTX = 0x200; // octal 0001000
992
993 private
994 {
995 extern (D) bool S_ISTYPE( mode_t mode, uint mask )
996 {
997 return ( mode & S_IFMT ) == mask;
998 }
999 }
1000
1001 extern (D) bool S_ISBLK( mode_t mode ) { return S_ISTYPE( mode, S_IFBLK ); }
1002 extern (D) bool S_ISCHR( mode_t mode ) { return S_ISTYPE( mode, S_IFCHR ); }
1003 extern (D) bool S_ISDIR( mode_t mode ) { return S_ISTYPE( mode, S_IFDIR ); }
1004 extern (D) bool S_ISFIFO( mode_t mode ) { return S_ISTYPE( mode, S_IFIFO ); }
1005 extern (D) bool S_ISREG( mode_t mode ) { return S_ISTYPE( mode, S_IFREG ); }
1006 extern (D) bool S_ISLNK( mode_t mode ) { return S_ISTYPE( mode, S_IFLNK ); }
1007 extern (D) bool S_ISSOCK( mode_t mode ) { return S_ISTYPE( mode, S_IFSOCK ); }
1008 }
1009 else version (Solaris)
1010 {
1011 private enum _ST_FSTYPSZ = 16;
1012
1013 version (D_LP64)
1014 {
1015 struct stat_t
1016 {
1017 dev_t st_dev;
1018 ino_t st_ino;
1019 mode_t st_mode;
1020 nlink_t st_nlink;
1021 uid_t st_uid;
1022 gid_t st_gid;
1023 dev_t st_rdev;
1024 off_t st_size;
1025 union
1026 {
1027 timestruc_t st_atim;
1028 time_t st_atime;
1029 }
1030 union
1031 {
1032 timestruc_t st_mtim;
1033 time_t st_mtime;
1034 }
1035 union
1036 {
1037 timestruc_t st_ctim;
1038 time_t st_ctime;
1039 }
1040 blksize_t st_blksize;
1041 blkcnt_t st_blocks;
1042 char[_ST_FSTYPSZ] st_fstype;
1043 }
1044
1045 static if (__USE_LARGEFILE64) alias stat_t stat64_t;
1046 }
1047 else
1048 {
1049 struct stat32_t
1050 {
1051 dev_t st_dev;
1052 c_long[3] st_pad1;
1053 ino_t st_ino;
1054 mode_t st_mode;
1055 nlink_t st_nlink;
1056 uid_t st_uid;
1057 gid_t st_gid;
1058 dev_t st_rdev;
1059 c_long[2] st_pad2;
1060 off_t st_size;
1061 c_long st_pad3;
1062 union
1063 {
1064 timestruc_t st_atim;
1065 time_t st_atime;
1066 }
1067 union
1068 {
1069 timestruc_t st_mtim;
1070 time_t st_mtime;
1071 }
1072 union
1073 {
1074 timestruc_t st_ctim;
1075 time_t st_ctime;
1076 }
1077 blksize_t st_blksize;
1078 blkcnt_t st_blocks;
1079 char[_ST_FSTYPSZ] st_fstype;
1080 c_long[8] st_pad4;
1081 }
1082
1083 struct stat64_t
1084 {
1085 dev_t st_dev;
1086 c_long[3] st_pad1;
1087 ino64_t st_ino;
1088 mode_t st_mode;
1089 nlink_t st_nlink;
1090 uid_t st_uid;
1091 gid_t st_gid;
1092 dev_t st_rdev;
1093 c_long[2] st_pad2;
1094 off64_t st_size;
1095 c_long st_pad3;
1096 union
1097 {
1098 timestruc_t st_atim;
1099 time_t st_atime;
1100 }
1101 union
1102 {
1103 timestruc_t st_mtim;
1104 time_t st_mtime;
1105 }
1106 union
1107 {
1108 timestruc_t st_ctim;
1109 time_t st_ctime;
1110 }
1111 blksize_t st_blksize;
1112 blkcnt64_t st_blocks;
1113 char[_ST_FSTYPSZ] st_fstype;
1114 c_long[8] st_pad4;
1115 }
1116
1117 static if (__USE_FILE_OFFSET64)
1118 alias stat64_t stat_t;
1119 else
1120 alias stat32_t stat_t;
1121
1122 }
1123
1124 enum S_IRUSR = 0x100;
1125 enum S_IWUSR = 0x080;
1126 enum S_IXUSR = 0x040;
1127 enum S_IRWXU = 0x1C0;
1128
1129 enum S_IRGRP = 0x020;
1130 enum S_IWGRP = 0x010;
1131 enum S_IXGRP = 0x008;
1132 enum S_IRWXG = 0x038;
1133
1134 enum S_IROTH = 0x4; // 0000004
1135 enum S_IWOTH = 0x2; // 0000002
1136 enum S_IXOTH = 0x1; // 0000001
1137 enum S_IRWXO = 0x7; // 0000007
1138
1139 enum S_ISUID = 0x800;
1140 enum S_ISGID = 0x400;
1141 enum S_ISVTX = 0x200;
1142
1143 private
1144 {
1145 extern (D) bool S_ISTYPE(mode_t mode, uint mask)
1146 {
1147 return (mode & S_IFMT) == mask;
1148 }
1149 }
1150
1151 extern (D) bool S_ISBLK(mode_t mode) { return S_ISTYPE(mode, S_IFBLK); }
1152 extern (D) bool S_ISCHR(mode_t mode) { return S_ISTYPE(mode, S_IFCHR); }
1153 extern (D) bool S_ISDIR(mode_t mode) { return S_ISTYPE(mode, S_IFDIR); }
1154 extern (D) bool S_ISFIFO(mode_t mode) { return S_ISTYPE(mode, S_IFIFO); }
1155 extern (D) bool S_ISREG(mode_t mode) { return S_ISTYPE(mode, S_IFREG); }
1156 extern (D) bool S_ISLNK(mode_t mode) { return S_ISTYPE(mode, S_IFLNK); }
1157 extern (D) bool S_ISSOCK(mode_t mode) { return S_ISTYPE(mode, S_IFSOCK); }
1158 extern (D) bool S_ISDOOR(mode_t mode) { return S_ISTYPE(mode, S_IFDOOR); }
1159 extern (D) bool S_ISPORT(mode_t mode) { return S_ISTYPE(mode, S_IFPORT); }
1160 }
1161 else version (CRuntime_Bionic)
1162 {
1163 version (X86)
1164 {
1165 struct stat_t
1166 {
1167 ulong st_dev;
1168 ubyte[4] __pad0;
1169 c_ulong __st_ino;
1170 uint st_mode;
1171 uint st_nlink;
1172 c_ulong st_uid;
1173 c_ulong st_gid;
1174 ulong st_rdev;
1175 ubyte[4] __pad3;
1176
1177 long st_size;
1178 c_ulong st_blksize;
1179 ulong st_blocks;
1180 c_ulong st_atime;
1181 c_ulong st_atime_nsec;
1182 c_ulong st_mtime;
1183 c_ulong st_mtime_nsec;
1184 c_ulong st_ctime;
1185 c_ulong st_ctime_nsec;
1186 ulong st_ino;
1187 }
1188 }
1189 else version (ARM)
1190 {
1191 struct stat_t
1192 {
1193 ulong st_dev;
1194 ubyte[4] __pad0;
1195 c_ulong __st_ino;
1196 uint st_mode;
1197 uint st_nlink;
1198 c_ulong st_uid;
1199 c_ulong st_gid;
1200 ulong st_rdev;
1201 ubyte[4] __pad3;
1202
1203 long st_size;
1204 c_ulong st_blksize;
1205 ulong st_blocks;
1206 c_ulong st_atime;
1207 c_ulong st_atime_nsec;
1208 c_ulong st_mtime;
1209 c_ulong st_mtime_nsec;
1210 c_ulong st_ctime;
1211 c_ulong st_ctime_nsec;
1212 ulong st_ino;
1213 }
1214 }
1215 else version (AArch64)
1216 {
1217 struct stat_t
1218 {
1219 ulong st_dev;
1220 ulong st_ino;
1221 uint st_mode;
1222 uint st_nlink;
1223 uid_t st_uid;
1224 gid_t st_gid;
1225 ulong st_rdev;
1226 ulong __pad1;
1227
1228 long st_size;
1229 int st_blksize;
1230 int __pad2;
1231 long st_blocks;
1232 long st_atime;
1233 ulong st_atime_nsec;
1234 long st_mtime;
1235 ulong st_mtime_nsec;
1236 long st_ctime;
1237 ulong st_ctime_nsec;
1238 uint __unused4;
1239 uint __unused5;
1240 }
1241 }
1242 else
1243 {
1244 static assert(false, "Architecture not supported.");
1245 }
1246
1247 enum S_IRUSR = 0x100; // octal 0000400
1248 enum S_IWUSR = 0x080; // octal 0000200
1249 enum S_IXUSR = 0x040; // octal 0000100
1250 enum S_IRWXU = 0x1C0; // octal 0000700
1251
1252 enum S_IRGRP = 0x020; // octal 0000040
1253 enum S_IWGRP = 0x010; // octal 0000020
1254 enum S_IXGRP = 0x008; // octal 0000010
1255 enum S_IRWXG = 0x038; // octal 0000070
1256
1257 enum S_IROTH = 0x4; // 0000004
1258 enum S_IWOTH = 0x2; // 0000002
1259 enum S_IXOTH = 0x1; // 0000001
1260 enum S_IRWXO = 0x7; // 0000007
1261
1262 enum S_ISUID = 0x800; // octal 0004000
1263 enum S_ISGID = 0x400; // octal 0002000
1264 enum S_ISVTX = 0x200; // octal 0001000
1265
1266 private
1267 {
1268 extern (D) bool S_ISTYPE( uint mode, uint mask )
1269 {
1270 return ( mode & S_IFMT ) == mask;
1271 }
1272 }
1273
1274 extern (D) bool S_ISBLK( uint mode ) { return S_ISTYPE( mode, S_IFBLK ); }
1275 extern (D) bool S_ISCHR( uint mode ) { return S_ISTYPE( mode, S_IFCHR ); }
1276 extern (D) bool S_ISDIR( uint mode ) { return S_ISTYPE( mode, S_IFDIR ); }
1277 extern (D) bool S_ISFIFO( uint mode ) { return S_ISTYPE( mode, S_IFIFO ); }
1278 extern (D) bool S_ISREG( uint mode ) { return S_ISTYPE( mode, S_IFREG ); }
1279 extern (D) bool S_ISLNK( uint mode ) { return S_ISTYPE( mode, S_IFLNK ); }
1280 extern (D) bool S_ISSOCK( uint mode ) { return S_ISTYPE( mode, S_IFSOCK ); }
1281
1282 // Added since Lollipop
1283 int utimensat(int dirfd, const char *pathname,
1284 ref const(timespec)[2] times, int flags);
1285 }
1286 else version (CRuntime_Musl)
1287 {
1288 alias __mode_t = uint;
1289 enum {
1290 S_IRUSR = 0x100, // octal 0400
1291 S_IWUSR = 0x080, // octal 0200
1292 S_IXUSR = 0x040, // octal 0100
1293 S_IRWXU = S_IRUSR | S_IWUSR | S_IXUSR,
1294
1295 S_IRGRP = S_IRUSR >> 3,
1296 S_IWGRP = S_IWUSR >> 3,
1297 S_IXGRP = S_IXUSR >> 3,
1298 S_IRWXG = S_IRWXU >> 3,
1299
1300 S_IROTH = S_IRGRP >> 3,
1301 S_IWOTH = S_IWGRP >> 3,
1302 S_IXOTH = S_IXGRP >> 3,
1303 S_IRWXO = S_IRWXG >> 3,
1304
1305 S_ISUID = 0x800, // octal 04000
1306 S_ISGID = 0x400, // octal 02000
1307 S_ISVTX = 0x200, // octal 01000
1308 }
1309 struct stat_t {
1310 dev_t st_dev;
1311 ino_t st_ino;
1312 nlink_t st_nlink;
1313
1314 mode_t st_mode;
1315 uid_t st_uid;
1316 gid_t st_gid;
1317 uint __pad0;
1318 dev_t st_rdev;
1319 off_t st_size;
1320 blksize_t st_blksize;
1321 blkcnt_t st_blocks;
1322
1323 timespec st_atim;
1324 timespec st_mtim;
1325 timespec st_ctim;
1326 extern(D) @safe @property
1327 {
1328 ref time_t st_atime() return { return st_atim.tv_sec; }
1329 ref time_t st_mtime() return { return st_mtim.tv_sec; }
1330 ref time_t st_ctime() return { return st_ctim.tv_sec; }
1331 }
1332 long[3] __unused;
1333 }
1334 private
1335 {
1336 extern (D) bool S_ISTYPE( mode_t mode, uint mask )
1337 {
1338 return ( mode & S_IFMT ) == mask;
1339 }
1340 }
1341
1342 extern (D) bool S_ISBLK( mode_t mode ) { return S_ISTYPE( mode, S_IFBLK ); }
1343 extern (D) bool S_ISCHR( mode_t mode ) { return S_ISTYPE( mode, S_IFCHR ); }
1344 extern (D) bool S_ISDIR( mode_t mode ) { return S_ISTYPE( mode, S_IFDIR ); }
1345 extern (D) bool S_ISFIFO( mode_t mode ) { return S_ISTYPE( mode, S_IFIFO ); }
1346 extern (D) bool S_ISREG( mode_t mode ) { return S_ISTYPE( mode, S_IFREG ); }
1347 extern (D) bool S_ISLNK( mode_t mode ) { return S_ISTYPE( mode, S_IFLNK ); }
1348 extern (D) bool S_ISSOCK( mode_t mode ) { return S_ISTYPE( mode, S_IFSOCK ); }
1349
1350 int utimensat(int dirfd, const char *pathname,
1351 ref const(timespec)[2] times, int flags);
1352 }
1353 else version (CRuntime_UClibc)
1354 {
1355 version (X86_64)
1356 {
1357 struct stat_t
1358 {
1359 dev_t st_dev;
1360 ino_t st_ino;
1361 nlink_t st_nlink;
1362 mode_t st_mode;
1363 uid_t st_uid;
1364 gid_t st_gid;
1365 uint __pad0;
1366 dev_t st_rdev;
1367 off_t st_size;
1368 blksize_t st_blksize;
1369 blkcnt_t st_blocks;
1370 time_t st_atime;
1371 ulong_t st_atimensec;
1372 time_t st_mtime;
1373 ulong_t st_mtimensec;
1374 time_t st_ctime;
1375 ulong_t st_ctimensec;
1376 slong_t[3] __unused;
1377 }
1378 }
1379 else version (MIPS_O32)
1380 {
1381 struct stat_t
1382 {
1383 c_ulong st_dev;
1384 c_long[3] st_pad1;
1385 ino_t st_ino;
1386 mode_t st_mode;
1387 nlink_t st_nlink;
1388 uid_t st_uid;
1389 gid_t st_gid;
1390 c_ulong st_rdev;
1391 static if (!__USE_FILE_OFFSET64)
1392 {
1393 c_long[2] st_pad2;
1394 off_t st_size;
1395 c_long st_pad3;
1396 }
1397 else
1398 {
1399 c_long[3] st_pad2;
1400 off_t st_size;
1401 }
1402 static if (__USE_MISC || __USE_XOPEN2K8)
1403 {
1404 timespec st_atim;
1405 timespec st_mtim;
1406 timespec st_ctim;
1407 extern(D)
1408 {
1409 @property ref time_t st_atime() { return st_atim.tv_sec; }
1410 @property ref time_t st_mtime() { return st_mtim.tv_sec; }
1411 @property ref time_t st_ctime() { return st_ctim.tv_sec; }
1412 }
1413 }
1414 else
1415 {
1416 time_t st_atime;
1417 c_ulong st_atimensec;
1418 time_t st_mtime;
1419 c_ulong st_mtimensec;
1420 time_t st_ctime;
1421 c_ulong st_ctimensec;
1422 }
1423 blksize_t st_blksize;
1424 static if (!__USE_FILE_OFFSET64)
1425 {
1426 blkcnt_t st_blocks;
1427 }
1428 else
1429 {
1430 c_long st_pad4;
1431 blkcnt_t st_blocks;
1432 }
1433 c_long[14] st_pad5;
1434 }
1435 }
1436 else version (ARM)
1437 {
1438 private
1439 {
1440 alias __dev_t = ulong;
1441 alias __ino_t = c_ulong;
1442 alias __ino64_t = ulong;
1443 alias __mode_t = uint;
1444 alias __nlink_t = size_t;
1445 alias __uid_t = uint;
1446 alias __gid_t = uint;
1447 alias __off_t = c_long;
1448 alias __off64_t = long;
1449 alias __blksize_t = c_long;
1450 alias __blkcnt_t = c_long;
1451 alias __blkcnt64_t = long;
1452 alias __timespec = timespec;
1453 alias __time_t = time_t;
1454 }
1455 struct stat_t
1456 {
1457 __dev_t st_dev;
1458 ushort __pad1;
1459
1460 static if (!__USE_FILE_OFFSET64)
1461 {
1462 __ino_t st_ino;
1463 }
1464 else
1465 {
1466 __ino_t __st_ino;
1467 }
1468 __mode_t st_mode;
1469 __nlink_t st_nlink;
1470 __uid_t st_uid;
1471 __gid_t st_gid;
1472 __dev_t st_rdev;
1473 ushort __pad2;
1474
1475 static if (!__USE_FILE_OFFSET64)
1476 {
1477 __off_t st_size;
1478 }
1479 else
1480 {
1481 __off64_t st_size;
1482 }
1483 __blksize_t st_blksize;
1484
1485 static if (!__USE_FILE_OFFSET64)
1486 {
1487 __blkcnt_t st_blocks;
1488 }
1489 else
1490 {
1491 __blkcnt64_t st_blocks;
1492 }
1493
1494 __time_t st_atime;
1495 c_ulong st_atimensec;
1496 __time_t st_mtime;
1497 c_ulong st_mtimensec;
1498 __time_t st_ctime;
1499 c_ulong st_ctimensec;
1500
1501 static if (!__USE_FILE_OFFSET64)
1502 {
1503 c_ulong __unused4;
1504 c_ulong __unused5;
1505 }
1506 else
1507 {
1508 __ino64_t st_ino;
1509 }
1510 }
1511 static if (__USE_FILE_OFFSET64)
1512 static assert(stat_t.sizeof == 104);
1513 else
1514 static assert(stat_t.sizeof == 88);
1515 }
1516 else
1517 static assert(0, "unimplemented");
1518
1519 enum S_IRUSR = 0x100; // octal 0400
1520 enum S_IWUSR = 0x080; // octal 0200
1521 enum S_IXUSR = 0x040; // octal 0100
1522 enum S_IRWXU = S_IRUSR | S_IWUSR | S_IXUSR;
1523
1524 enum S_IRGRP = S_IRUSR >> 3;
1525 enum S_IWGRP = S_IWUSR >> 3;
1526 enum S_IXGRP = S_IXUSR >> 3;
1527 enum S_IRWXG = S_IRWXU >> 3;
1528
1529 enum S_IROTH = S_IRGRP >> 3;
1530 enum S_IWOTH = S_IWGRP >> 3;
1531 enum S_IXOTH = S_IXGRP >> 3;
1532 enum S_IRWXO = S_IRWXG >> 3;
1533
1534 enum S_ISUID = 0x800; // octal 04000
1535 enum S_ISGID = 0x400; // octal 02000
1536 enum S_ISVTX = 0x200; // octal 01000
1537
1538 private
1539 {
1540 extern (D) bool S_ISTYPE( mode_t mode, uint mask )
1541 {
1542 return ( mode & S_IFMT ) == mask;
1543 }
1544 }
1545
1546 extern (D) bool S_ISBLK( mode_t mode ) { return S_ISTYPE( mode, S_IFBLK ); }
1547 extern (D) bool S_ISCHR( mode_t mode ) { return S_ISTYPE( mode, S_IFCHR ); }
1548 extern (D) bool S_ISDIR( mode_t mode ) { return S_ISTYPE( mode, S_IFDIR ); }
1549 extern (D) bool S_ISFIFO( mode_t mode ) { return S_ISTYPE( mode, S_IFIFO ); }
1550 extern (D) bool S_ISREG( mode_t mode ) { return S_ISTYPE( mode, S_IFREG ); }
1551 extern (D) bool S_ISLNK( mode_t mode ) { return S_ISTYPE( mode, S_IFLNK ); }
1552 extern (D) bool S_ISSOCK( mode_t mode ) { return S_ISTYPE( mode, S_IFSOCK ); }
1553
1554 static if ( true /*__USE_POSIX199309*/ )
1555 {
1556 extern bool S_TYPEISMQ( stat_t* buf ) { return false; }
1557 extern bool S_TYPEISSEM( stat_t* buf ) { return false; }
1558 extern bool S_TYPEISSHM( stat_t* buf ) { return false; }
1559 }
1560
1561 enum UTIME_NOW = 0x3fffffff;
1562 enum UTIME_OMIT = 0x3ffffffe;
1563
1564 int utimensat(int dirfd, const char *pathname,
1565 ref const(timespec)[2] times, int flags);
1566 int futimens(int fd, ref const(timespec)[2] times);
1567 }
1568 else
1569 {
1570 static assert(false, "Unsupported platform");
1571 }
1572
1573 int chmod(in char*, mode_t);
1574 int fchmod(int, mode_t);
1575 //int fstat(int, stat_t*);
1576 //int lstat(in char*, stat_t*);
1577 int mkdir(in char*, mode_t);
1578 int mkfifo(in char*, mode_t);
1579 //int stat(in char*, stat_t*);
1580 mode_t umask(mode_t);
1581
1582 version (CRuntime_Glibc)
1583 {
1584 static if ( __USE_LARGEFILE64 )
1585 {
1586 int fstat64(int, stat_t*) @trusted;
1587 alias fstat64 fstat;
1588
1589 int lstat64(in char*, stat_t*);
1590 alias lstat64 lstat;
1591
1592 int stat64(in char*, stat_t*);
1593 alias stat64 stat;
1594 }
1595 else
1596 {
1597 int fstat(int, stat_t*) @trusted;
1598 int lstat(in char*, stat_t*);
1599 int stat(in char*, stat_t*);
1600 }
1601 }
1602 else version (Solaris)
1603 {
1604 version (D_LP64)
1605 {
1606 int fstat(int, stat_t*) @trusted;
1607 int lstat(in char*, stat_t*);
1608 int stat(in char*, stat_t*);
1609
1610 static if (__USE_LARGEFILE64)
1611 {
1612 alias fstat fstat64;
1613 alias lstat lstat64;
1614 alias stat stat64;
1615 }
1616 }
1617 else
1618 {
1619 static if (__USE_LARGEFILE64)
1620 {
1621 int fstat64(int, stat_t*) @trusted;
1622 alias fstat64 fstat;
1623
1624 int lstat64(in char*, stat_t*);
1625 alias lstat64 lstat;
1626
1627 int stat64(in char*, stat_t*);
1628 alias stat64 stat;
1629 }
1630 else
1631 {
1632 int fstat(int, stat_t*) @trusted;
1633 int lstat(in char*, stat_t*);
1634 int stat(in char*, stat_t*);
1635 }
1636 }
1637 }
1638 else version (Darwin)
1639 {
1640 // OS X maintains backwards compatibility with older binaries using 32-bit
1641 // inode functions by appending $INODE64 to newer 64-bit inode functions.
1642 version (OSX)
1643 {
1644 pragma(mangle, "fstat$INODE64") int fstat(int, stat_t*);
1645 pragma(mangle, "lstat$INODE64") int lstat(in char*, stat_t*);
1646 pragma(mangle, "stat$INODE64") int stat(in char*, stat_t*);
1647 }
1648 else
1649 {
1650 int fstat(int, stat_t*);
1651 int lstat(in char*, stat_t*);
1652 int stat(in char*, stat_t*);
1653 }
1654 }
1655 else version (FreeBSD)
1656 {
1657 int fstat(int, stat_t*);
1658 int lstat(in char*, stat_t*);
1659 int stat(in char*, stat_t*);
1660 }
1661 else version (NetBSD)
1662 {
1663 int __fstat50(int, stat_t*);
1664 int __lstat50(in char*, stat_t*);
1665 int __stat50(in char*, stat_t*);
1666 alias __fstat50 fstat;
1667 alias __lstat50 lstat;
1668 alias __stat50 stat;
1669 }
1670 else version (DragonFlyBSD)
1671 {
1672 int fstat(int, stat_t*);
1673 int lstat(in char*, stat_t*);
1674 int stat(in char*, stat_t*);
1675 }
1676 else version (CRuntime_Bionic)
1677 {
1678 int fstat(int, stat_t*) @trusted;
1679 int lstat(in char*, stat_t*);
1680 int stat(in char*, stat_t*);
1681 }
1682 else version (CRuntime_Musl)
1683 {
1684 int stat(in char*, stat_t*);
1685 int fstat(int, stat_t*);
1686 int lstat(in char*, stat_t*);
1687
1688 alias fstat fstat64;
1689 alias lstat lstat64;
1690 alias stat stat64;
1691 }
1692 else version (CRuntime_UClibc)
1693 {
1694 static if ( __USE_LARGEFILE64 )
1695 {
1696 int fstat64(int, stat_t*) @trusted;
1697 alias fstat64 fstat;
1698
1699 int lstat64(in char*, stat_t*);
1700 alias lstat64 lstat;
1701
1702 int stat64(in char*, stat_t*);
1703 alias stat64 stat;
1704 }
1705 else
1706 {
1707 int fstat(int, stat_t*) @trusted;
1708 int lstat(in char*, stat_t*);
1709 int stat(in char*, stat_t*);
1710 }
1711 }
1712
1713 //
1714 // Typed Memory Objects (TYM)
1715 //
1716 /*
1717 S_TYPEISTMO(buf)
1718 */
1719
1720 //
1721 // XOpen (XSI)
1722 //
1723 /*
1724 S_IFMT
1725 S_IFBLK
1726 S_IFCHR
1727 S_IFIFO
1728 S_IFREG
1729 S_IFDIR
1730 S_IFLNK
1731 S_IFSOCK
1732
1733 int mknod(in 3char*, mode_t, dev_t);
1734 */
1735
1736 version (CRuntime_Glibc)
1737 {
1738 enum S_IFMT = 0xF000; // octal 0170000
1739 enum S_IFBLK = 0x6000; // octal 0060000
1740 enum S_IFCHR = 0x2000; // octal 0020000
1741 enum S_IFIFO = 0x1000; // octal 0010000
1742 enum S_IFREG = 0x8000; // octal 0100000
1743 enum S_IFDIR = 0x4000; // octal 0040000
1744 enum S_IFLNK = 0xA000; // octal 0120000
1745 enum S_IFSOCK = 0xC000; // octal 0140000
1746
1747 int mknod(in char*, mode_t, dev_t);
1748 }
1749 else version (Darwin)
1750 {
1751 enum S_IFMT = 0xF000; // octal 0170000
1752 enum S_IFBLK = 0x6000; // octal 0060000
1753 enum S_IFCHR = 0x2000; // octal 0020000
1754 enum S_IFIFO = 0x1000; // octal 0010000
1755 enum S_IFREG = 0x8000; // octal 0100000
1756 enum S_IFDIR = 0x4000; // octal 0040000
1757 enum S_IFLNK = 0xA000; // octal 0120000
1758 enum S_IFSOCK = 0xC000; // octal 0140000
1759
1760 int mknod(in char*, mode_t, dev_t);
1761 }
1762 else version (FreeBSD)
1763 {
1764 enum S_IFMT = 0xF000; // octal 0170000
1765 enum S_IFBLK = 0x6000; // octal 0060000
1766 enum S_IFCHR = 0x2000; // octal 0020000
1767 enum S_IFIFO = 0x1000; // octal 0010000
1768 enum S_IFREG = 0x8000; // octal 0100000
1769 enum S_IFDIR = 0x4000; // octal 0040000
1770 enum S_IFLNK = 0xA000; // octal 0120000
1771 enum S_IFSOCK = 0xC000; // octal 0140000
1772
1773 int mknod(in char*, mode_t, dev_t);
1774 }
1775 else version (NetBSD)
1776 {
1777 enum S_IFMT = 0xF000; // octal 0170000
1778 enum S_IFBLK = 0x6000; // octal 0060000
1779 enum S_IFCHR = 0x2000; // octal 0020000
1780 enum S_IFIFO = 0x1000; // octal 0010000
1781 enum S_IFREG = 0x8000; // octal 0100000
1782 enum S_IFDIR = 0x4000; // octal 0040000
1783 enum S_IFLNK = 0xA000; // octal 0120000
1784 enum S_IFSOCK = 0xC000; // octal 0140000
1785
1786 int mknod(in char*, mode_t, dev_t);
1787 }
1788 else version (DragonFlyBSD)
1789 {
1790 enum S_IFMT = 0xF000; // octal 0170000
1791 enum S_IFBLK = 0x6000; // octal 0060000
1792 enum S_IFCHR = 0x2000; // octal 0020000
1793 enum S_IFIFO = 0x1000; // octal 0010000
1794 enum S_IFREG = 0x8000; // octal 0100000
1795 enum S_IFDIR = 0x4000; // octal 0040000
1796 enum S_IFLNK = 0xA000; // octal 0120000
1797 enum S_IFSOCK = 0xC000; // octal 0140000
1798
1799 int mknod(in char*, mode_t, dev_t);
1800 }
1801 else version (Solaris)
1802 {
1803 enum S_IFMT = 0xF000;
1804 enum S_IFBLK = 0x6000;
1805 enum S_IFCHR = 0x2000;
1806 enum S_IFIFO = 0x1000;
1807 enum S_IFREG = 0x8000;
1808 enum S_IFDIR = 0x4000;
1809 enum S_IFLNK = 0xA000;
1810 enum S_IFSOCK = 0xC000;
1811 enum S_IFDOOR = 0xD000;
1812 enum S_IFPORT = 0xE000;
1813
1814 int mknod(in char*, mode_t, dev_t);
1815 }
1816 else version (CRuntime_Bionic)
1817 {
1818 enum S_IFMT = 0xF000; // octal 0170000
1819 enum S_IFBLK = 0x6000; // octal 0060000
1820 enum S_IFCHR = 0x2000; // octal 0020000
1821 enum S_IFIFO = 0x1000; // octal 0010000
1822 enum S_IFREG = 0x8000; // octal 0100000
1823 enum S_IFDIR = 0x4000; // octal 0040000
1824 enum S_IFLNK = 0xA000; // octal 0120000
1825 enum S_IFSOCK = 0xC000; // octal 0140000
1826
1827 int mknod(in char*, mode_t, dev_t);
1828 }
1829 else version (CRuntime_Musl)
1830 {
1831 enum {
1832 S_IFMT = 0xF000, // octal 0170000
1833 S_IFBLK = 0x6000, // octal 0060000
1834 S_IFCHR = 0x2000, // octal 0020000
1835 S_IFIFO = 0x1000, // octal 0010000
1836 S_IFREG = 0x8000, // octal 0100000
1837 S_IFDIR = 0x4000, // octal 0040000
1838 S_IFLNK = 0xA000, // octal 0120000
1839 S_IFSOCK = 0xC000, // octal 0140000
1840 }
1841
1842 int mknod(in char*, mode_t, dev_t);
1843 }
1844 else version (CRuntime_UClibc)
1845 {
1846 enum S_IFMT = 0xF000; // octal 0170000
1847 enum S_IFBLK = 0x6000; // octal 0060000
1848 enum S_IFCHR = 0x2000; // octal 0020000
1849 enum S_IFIFO = 0x1000; // octal 0010000
1850 enum S_IFREG = 0x8000; // octal 0100000
1851 enum S_IFDIR = 0x4000; // octal 0040000
1852 enum S_IFLNK = 0xA000; // octal 0120000
1853 enum S_IFSOCK = 0xC000; // octal 0140000
1854
1855 int mknod(in char*, mode_t, dev_t);
1856 }
1857 else
1858 {
1859 static assert(false, "Unsupported platform");
1860 }
Mirror of https://gcc.gnu.org/git/gcc.git