libphobos/libdruntime/core/sys/posix/sys/utsname.d

   1
   2 // Interface to <sys/utsname.h>
   3
   4 module core.sys.posix.sys.utsname;
   5
   6 version (OSX)
   7     version = Darwin;
   8 else version (iOS)
   9     version = Darwin;
  10 else version (TVOS)
  11     version = Darwin;
  12 else version (WatchOS)
  13     version = Darwin;
  14
  15 version (Posix):
  16 extern(C):
  17 nothrow:
  18 @nogc:
  19
  20 version (CRuntime_Glibc)
  21 {
  22     private enum utsNameLength = 65;
  23
  24     struct utsname
  25     {
  26         char[utsNameLength] sysname = 0;
  27         char[utsNameLength] nodename = 0;
  28         char[utsNameLength] release = 0;
  29         char[utsNameLength] version_ = 0;
  30         // TODO Deprecate after version_ has been in an official release.
  31         alias update = version_;
  32         char[utsNameLength] machine = 0;
  33
  34         char[utsNameLength] __domainname = 0;
  35     }
  36
  37     int uname(utsname* __name);
  38 }
  39 else version (Darwin)
  40 {
  41     private enum utsNameLength = 256;
  42
  43     struct utsname
  44     {
  45         char[utsNameLength] sysname = 0;
  46         char[utsNameLength] nodename = 0;
  47         char[utsNameLength] release = 0;
  48         char[utsNameLength] version_ = 0;
  49         // TODO Deprecate after version_ has been in an official release.
  50         alias update = version_;
  51         char[utsNameLength] machine = 0;
  52     }
  53
  54     int uname(utsname* __name);
  55 }
  56 else version (FreeBSD)
  57 {
  58     //private enum SYS_NMLN = 32;       // old FreeBSD 1.1 ABI
  59     private enum SYS_NMLN = 256;
  60
  61     struct utsname
  62     {
  63         char[SYS_NMLN] sysname = 0;
  64         char[SYS_NMLN] nodename = 0;
  65         char[SYS_NMLN] release = 0;
  66         char[SYS_NMLN] version_ = 0;
  67         // TODO Deprecate after version_ has been in an official release.
  68         alias update = version_;
  69         char[SYS_NMLN] machine = 0;
  70     }
  71
  72     int __xuname(int, void*);
  73     int uname()(utsname* __name) { return __xuname(SYS_NMLN, cast(void*) __name); }
  74 }
  75 else version (NetBSD)
  76 {
  77     private enum utsNameLength = 256;
  78
  79     struct utsname
  80     {
  81         char[utsNameLength] sysname = 0;
  82         char[utsNameLength] nodename = 0;
  83         char[utsNameLength] release = 0;
  84         char[utsNameLength] version_ = 0;
  85         // TODO Deprecate after version_ has been in an official release.
  86         alias update = version_;
  87         char[utsNameLength] machine = 0;
  88     }
  89
  90     int uname(utsname* __name);
  91 }
  92 else version (OpenBSD)
  93 {
  94     private enum utsNameLength = 256;
  95
  96     struct utsname
  97     {
  98         char[utsNameLength] sysname = 0;
  99         char[utsNameLength] nodename = 0;
 100         char[utsNameLength] release = 0;
 101         char[utsNameLength] version_ = 0;
 102         char[utsNameLength] machine = 0;
 103     }
 104
 105     int uname(utsname* __name);
 106 }
 107 else version (DragonFlyBSD)
 108 {
 109     private enum utsNameLength = 32;
 110
 111     struct utsname
 112     {
 113         char[utsNameLength] sysname = 0;
 114         char[utsNameLength] nodename = 0;
 115         char[utsNameLength] release = 0;
 116         char[utsNameLength] version_ = 0;
 117         // TODO Deprecate after version_ has been in an official release.
 118         alias update = version_;
 119         char[utsNameLength] machine = 0;
 120     }
 121
 122     int uname(utsname* __name);
 123 }
 124 else version (Solaris)
 125 {
 126     private enum SYS_NMLN = 257;
 127
 128     struct utsname
 129     {
 130         char[SYS_NMLN] sysname = 0;
 131         char[SYS_NMLN] nodename = 0;
 132         char[SYS_NMLN] release = 0;
 133         // The field name is version but version is a keyword in D.
 134         char[SYS_NMLN] _version = 0;
 135         char[SYS_NMLN] machine = 0;
 136     }
 137
 138     int uname(utsname* __name);
 139 }
 140 else version (CRuntime_Bionic)
 141 {
 142     private enum SYS_NMLN = 65;
 143
 144     struct utsname
 145     {
 146         char[SYS_NMLN] sysname = 0;
 147         char[SYS_NMLN] nodename = 0;
 148         char[SYS_NMLN] release = 0;
 149         // The field name is version but version is a keyword in D.
 150         char[SYS_NMLN] _version = 0;
 151         char[SYS_NMLN] machine = 0;
 152         char[SYS_NMLN] domainname = 0;
 153     }
 154
 155     int uname(utsname*);
 156 }
 157 else version (CRuntime_Musl)
 158 {
 159     private enum SYS_NMLN = 65;
 160
 161     struct utsname
 162     {
 163         char[SYS_NMLN] sysname = 0;
 164         char[SYS_NMLN] nodename = 0;
 165         char[SYS_NMLN] release = 0;
 166         char[SYS_NMLN] _version = 0;
 167         char[SYS_NMLN] machine = 0;
 168         char[SYS_NMLN] domainname = 0;
 169     }
 170
 171     int uname(utsname*);
 172 }
 173 else version (CRuntime_UClibc)
 174 {
 175     private enum utsNameLength = 65;
 176
 177     struct utsname
 178     {
 179         char[utsNameLength] sysname = 0;
 180         char[utsNameLength] nodename = 0;
 181         char[utsNameLength] release = 0;
 182         char[utsNameLength] version_ = 0;
 183         char[utsNameLength] machine = 0;
 184         char[utsNameLength] domainname = 0;
 185     }
 186
 187     int uname(utsname*);
 188 }
 189 else
 190 {
 191     static assert(false, "unsupported system");
 192 }