1 module tfd.c_api.linux; 2 version (linux): 3 4 import core.stdc.config; 5 import core.stdc.stdarg: va_list; 6 static import core.simd; 7 static import std.conv; 8 9 struct Int128 { long lower; long upper; } 10 struct UInt128 { ulong lower; ulong upper; } 11 12 struct __locale_data { int dummy; } 13 14 15 16 alias _Bool = bool; 17 struct dpp { 18 static struct Opaque(int N) { 19 void[N] bytes; 20 } 21 22 static bool isEmpty(T)() { 23 return T.tupleof.length == 0; 24 } 25 static struct Move(T) { 26 T* ptr; 27 } 28 29 30 static auto move(T)(ref T value) { 31 return Move!T(&value); 32 } 33 mixin template EnumD(string name, T, string prefix) if(is(T == enum)) { 34 private static string _memberMixinStr(string member) { 35 import std.conv: text; 36 import std.array: replace; 37 return text(` `, member.replace(prefix, ""), ` = `, T.stringof, `.`, member, `,`); 38 } 39 private static string _enumMixinStr() { 40 import std.array: join; 41 string[] ret; 42 ret ~= "enum " ~ name ~ "{"; 43 static foreach(member; __traits(allMembers, T)) { 44 ret ~= _memberMixinStr(member); 45 } 46 ret ~= "}"; 47 return ret.join("\n"); 48 } 49 mixin(_enumMixinStr()); 50 } 51 } 52 53 extern(C) 54 { 55 bool TF_TensorIsAligned(const(TF_Tensor)*) @nogc nothrow; 56 c_ulong TF_StringEncodedSize(c_ulong) @nogc nothrow; 57 c_ulong TF_StringDecode(const(char)*, c_ulong, const(char)**, c_ulong*, TF_Status*) @nogc nothrow; 58 c_ulong TF_StringEncode(const(char)*, c_ulong, char*, c_ulong, TF_Status*) @nogc nothrow; 59 void TF_TensorBitcastFrom(const(TF_Tensor)*, TF_DataType, TF_Tensor*, const(c_long)*, int, TF_Status*) @nogc nothrow; 60 c_long TF_TensorElementCount(const(TF_Tensor)*) @nogc nothrow; 61 void* TF_TensorData(const(TF_Tensor)*) @nogc nothrow; 62 c_ulong TF_TensorByteSize(const(TF_Tensor)*) @nogc nothrow; 63 c_long TF_Dim(const(TF_Tensor)*, int) @nogc nothrow; 64 int TF_NumDims(const(TF_Tensor)*) @nogc nothrow; 65 TF_DataType TF_TensorType(const(TF_Tensor)*) @nogc nothrow; 66 void TF_DeleteTensor(TF_Tensor*) @nogc nothrow; 67 TF_Tensor* TF_TensorMaybeMove(TF_Tensor*) @nogc nothrow; 68 TF_Tensor* TF_AllocateTensor(TF_DataType, const(c_long)*, int, c_ulong) @nogc nothrow; 69 TF_Tensor* TF_NewTensor(TF_DataType, const(c_long)*, int, void*, c_ulong, void function(void*, c_ulong, void*), void*) @nogc nothrow; 70 struct TF_Tensor; 71 const(char)* TF_Message(const(TF_Status)*) @nogc nothrow; 72 TF_Code TF_GetCode(const(TF_Status)*) @nogc nothrow; 73 void TF_SetStatus(TF_Status*, TF_Code, const(char)*) @nogc nothrow; 74 void TF_DeleteStatus(TF_Status*) @nogc nothrow; 75 TF_Status* TF_NewStatus() @nogc nothrow; 76 enum TF_Code 77 { 78 TF_OK = 0, 79 TF_CANCELLED = 1, 80 TF_UNKNOWN = 2, 81 TF_INVALID_ARGUMENT = 3, 82 TF_DEADLINE_EXCEEDED = 4, 83 TF_NOT_FOUND = 5, 84 TF_ALREADY_EXISTS = 6, 85 TF_PERMISSION_DENIED = 7, 86 TF_UNAUTHENTICATED = 16, 87 TF_RESOURCE_EXHAUSTED = 8, 88 TF_FAILED_PRECONDITION = 9, 89 TF_ABORTED = 10, 90 TF_OUT_OF_RANGE = 11, 91 TF_UNIMPLEMENTED = 12, 92 TF_INTERNAL = 13, 93 TF_UNAVAILABLE = 14, 94 TF_DATA_LOSS = 15, 95 } 96 enum TF_OK = TF_Code.TF_OK; 97 enum TF_CANCELLED = TF_Code.TF_CANCELLED; 98 enum TF_UNKNOWN = TF_Code.TF_UNKNOWN; 99 enum TF_INVALID_ARGUMENT = TF_Code.TF_INVALID_ARGUMENT; 100 enum TF_DEADLINE_EXCEEDED = TF_Code.TF_DEADLINE_EXCEEDED; 101 enum TF_NOT_FOUND = TF_Code.TF_NOT_FOUND; 102 enum TF_ALREADY_EXISTS = TF_Code.TF_ALREADY_EXISTS; 103 enum TF_PERMISSION_DENIED = TF_Code.TF_PERMISSION_DENIED; 104 enum TF_UNAUTHENTICATED = TF_Code.TF_UNAUTHENTICATED; 105 enum TF_RESOURCE_EXHAUSTED = TF_Code.TF_RESOURCE_EXHAUSTED; 106 enum TF_FAILED_PRECONDITION = TF_Code.TF_FAILED_PRECONDITION; 107 enum TF_ABORTED = TF_Code.TF_ABORTED; 108 enum TF_OUT_OF_RANGE = TF_Code.TF_OUT_OF_RANGE; 109 enum TF_UNIMPLEMENTED = TF_Code.TF_UNIMPLEMENTED; 110 enum TF_INTERNAL = TF_Code.TF_INTERNAL; 111 enum TF_UNAVAILABLE = TF_Code.TF_UNAVAILABLE; 112 enum TF_DATA_LOSS = TF_Code.TF_DATA_LOSS; 113 struct TF_Status; 114 c_ulong TF_DataTypeSize(TF_DataType) @nogc nothrow; 115 enum TF_DataType 116 { 117 TF_FLOAT = 1, 118 TF_DOUBLE = 2, 119 TF_INT32 = 3, 120 TF_UINT8 = 4, 121 TF_INT16 = 5, 122 TF_INT8 = 6, 123 TF_STRING = 7, 124 TF_COMPLEX64 = 8, 125 TF_COMPLEX = 8, 126 TF_INT64 = 9, 127 TF_BOOL = 10, 128 TF_QINT8 = 11, 129 TF_QUINT8 = 12, 130 TF_QINT32 = 13, 131 TF_BFLOAT16 = 14, 132 TF_QINT16 = 15, 133 TF_QUINT16 = 16, 134 TF_UINT16 = 17, 135 TF_COMPLEX128 = 18, 136 TF_HALF = 19, 137 TF_RESOURCE = 20, 138 TF_VARIANT = 21, 139 TF_UINT32 = 22, 140 TF_UINT64 = 23, 141 } 142 enum TF_FLOAT = TF_DataType.TF_FLOAT; 143 enum TF_DOUBLE = TF_DataType.TF_DOUBLE; 144 enum TF_INT32 = TF_DataType.TF_INT32; 145 enum TF_UINT8 = TF_DataType.TF_UINT8; 146 enum TF_INT16 = TF_DataType.TF_INT16; 147 enum TF_INT8 = TF_DataType.TF_INT8; 148 enum TF_STRING = TF_DataType.TF_STRING; 149 enum TF_COMPLEX64 = TF_DataType.TF_COMPLEX64; 150 enum TF_COMPLEX = TF_DataType.TF_COMPLEX; 151 enum TF_INT64 = TF_DataType.TF_INT64; 152 enum TF_BOOL = TF_DataType.TF_BOOL; 153 enum TF_QINT8 = TF_DataType.TF_QINT8; 154 enum TF_QUINT8 = TF_DataType.TF_QUINT8; 155 enum TF_QINT32 = TF_DataType.TF_QINT32; 156 enum TF_BFLOAT16 = TF_DataType.TF_BFLOAT16; 157 enum TF_QINT16 = TF_DataType.TF_QINT16; 158 enum TF_QUINT16 = TF_DataType.TF_QUINT16; 159 enum TF_UINT16 = TF_DataType.TF_UINT16; 160 enum TF_COMPLEX128 = TF_DataType.TF_COMPLEX128; 161 enum TF_HALF = TF_DataType.TF_HALF; 162 enum TF_RESOURCE = TF_DataType.TF_RESOURCE; 163 enum TF_VARIANT = TF_DataType.TF_VARIANT; 164 enum TF_UINT32 = TF_DataType.TF_UINT32; 165 enum TF_UINT64 = TF_DataType.TF_UINT64; 166 enum TF_AttrType 167 { 168 TF_ATTR_STRING = 0, 169 TF_ATTR_INT = 1, 170 TF_ATTR_FLOAT = 2, 171 TF_ATTR_BOOL = 3, 172 TF_ATTR_TYPE = 4, 173 TF_ATTR_SHAPE = 5, 174 TF_ATTR_TENSOR = 6, 175 TF_ATTR_PLACEHOLDER = 7, 176 TF_ATTR_FUNC = 8, 177 } 178 enum TF_ATTR_STRING = TF_AttrType.TF_ATTR_STRING; 179 enum TF_ATTR_INT = TF_AttrType.TF_ATTR_INT; 180 enum TF_ATTR_FLOAT = TF_AttrType.TF_ATTR_FLOAT; 181 enum TF_ATTR_BOOL = TF_AttrType.TF_ATTR_BOOL; 182 enum TF_ATTR_TYPE = TF_AttrType.TF_ATTR_TYPE; 183 enum TF_ATTR_SHAPE = TF_AttrType.TF_ATTR_SHAPE; 184 enum TF_ATTR_TENSOR = TF_AttrType.TF_ATTR_TENSOR; 185 enum TF_ATTR_PLACEHOLDER = TF_AttrType.TF_ATTR_PLACEHOLDER; 186 enum TF_ATTR_FUNC = TF_AttrType.TF_ATTR_FUNC; 187 alias __sig_atomic_t = int; 188 alias __socklen_t = uint; 189 alias __intptr_t = c_long; 190 alias __caddr_t = char*; 191 alias __loff_t = c_long; 192 alias __syscall_ulong_t = c_ulong; 193 alias __syscall_slong_t = c_long; 194 alias __ssize_t = c_long; 195 alias __fsword_t = c_long; 196 alias __fsfilcnt64_t = c_ulong; 197 alias __fsfilcnt_t = c_ulong; 198 alias __fsblkcnt64_t = c_ulong; 199 alias __fsblkcnt_t = c_ulong; 200 alias __blkcnt64_t = c_long; 201 alias __blkcnt_t = c_long; 202 alias __blksize_t = c_long; 203 alias __timer_t = void*; 204 alias __clockid_t = int; 205 alias __key_t = int; 206 alias __daddr_t = int; 207 alias __suseconds_t = c_long; 208 alias __useconds_t = uint; 209 alias __time_t = c_long; 210 alias __id_t = uint; 211 alias __rlim64_t = c_ulong; 212 alias __rlim_t = c_ulong; 213 alias __clock_t = c_long; 214 struct __fsid_t 215 { 216 int[2] __val; 217 } 218 alias __pid_t = int; 219 alias __off64_t = c_long; 220 alias __off_t = c_long; 221 alias __nlink_t = c_ulong; 222 alias __mode_t = uint; 223 alias __ino64_t = c_ulong; 224 alias __ino_t = c_ulong; 225 alias __gid_t = uint; 226 alias __uid_t = uint; 227 alias __dev_t = c_ulong; 228 alias __uintmax_t = c_ulong; 229 alias __intmax_t = c_long; 230 alias __u_quad_t = c_ulong; 231 alias __quad_t = c_long; 232 alias __uint64_t = c_ulong; 233 alias __int64_t = c_long; 234 alias __uint32_t = uint; 235 alias __int32_t = int; 236 alias __uint16_t = ushort; 237 alias __int16_t = short; 238 alias __uint8_t = ubyte; 239 alias __int8_t = byte; 240 alias __u_long = c_ulong; 241 alias __u_int = uint; 242 alias __u_short = ushort; 243 alias __u_char = ubyte; 244 alias uint64_t = ulong; 245 alias uint32_t = uint; 246 alias uint16_t = ushort; 247 alias uint8_t = ubyte; 248 alias int64_t = c_long; 249 alias int32_t = int; 250 alias int16_t = short; 251 alias int8_t = byte; 252 alias uintmax_t = c_ulong; 253 alias intmax_t = c_long; 254 alias uintptr_t = c_ulong; 255 alias intptr_t = c_long; 256 alias uint_fast64_t = c_ulong; 257 alias uint_fast32_t = c_ulong; 258 alias uint_fast16_t = c_ulong; 259 alias uint_fast8_t = ubyte; 260 alias int_fast64_t = c_long; 261 alias int_fast32_t = c_long; 262 alias int_fast16_t = c_long; 263 alias int_fast8_t = byte; 264 alias uint_least64_t = c_ulong; 265 alias uint_least32_t = uint; 266 alias uint_least16_t = ushort; 267 alias uint_least8_t = ubyte; 268 alias int_least64_t = c_long; 269 alias int_least32_t = int; 270 alias int_least16_t = short; 271 alias int_least8_t = byte; 272 const(char)* TF_Version() @nogc nothrow; 273 struct TF_Buffer 274 { 275 const(void)* data; 276 c_ulong length; 277 void function(void*, c_ulong) data_deallocator; 278 } 279 TF_Buffer* TF_NewBufferFromString(const(void)*, c_ulong) @nogc nothrow; 280 TF_Buffer* TF_NewBuffer() @nogc nothrow; 281 void TF_DeleteBuffer(TF_Buffer*) @nogc nothrow; 282 TF_Buffer TF_GetBuffer(TF_Buffer*) @nogc nothrow; 283 struct TF_SessionOptions; 284 TF_SessionOptions* TF_NewSessionOptions() @nogc nothrow; 285 void TF_SetTarget(TF_SessionOptions*, const(char)*) @nogc nothrow; 286 void TF_SetConfig(TF_SessionOptions*, const(void)*, c_ulong, TF_Status*) @nogc nothrow; 287 void TF_DeleteSessionOptions(TF_SessionOptions*) @nogc nothrow; 288 struct TF_Graph; 289 TF_Graph* TF_NewGraph() @nogc nothrow; 290 void TF_DeleteGraph(TF_Graph*) @nogc nothrow; 291 struct TF_OperationDescription; 292 struct TF_Operation; 293 struct TF_Input 294 { 295 TF_Operation* oper; 296 int index; 297 } 298 struct TF_Output 299 { 300 TF_Operation* oper; 301 int index; 302 } 303 struct TF_Function; 304 struct TF_FunctionOptions; 305 void TF_GraphSetTensorShape(TF_Graph*, TF_Output, const(c_long)*, const(int), TF_Status*) @nogc nothrow; 306 int TF_GraphGetTensorNumDims(TF_Graph*, TF_Output, TF_Status*) @nogc nothrow; 307 void TF_GraphGetTensorShape(TF_Graph*, TF_Output, c_long*, int, TF_Status*) @nogc nothrow; 308 TF_OperationDescription* TF_NewOperation(TF_Graph*, const(char)*, const(char)*) @nogc nothrow; 309 void TF_SetDevice(TF_OperationDescription*, const(char)*) @nogc nothrow; 310 void TF_AddInput(TF_OperationDescription*, TF_Output) @nogc nothrow; 311 void TF_AddInputList(TF_OperationDescription*, const(TF_Output)*, int) @nogc nothrow; 312 void TF_AddControlInput(TF_OperationDescription*, TF_Operation*) @nogc nothrow; 313 void TF_ColocateWith(TF_OperationDescription*, TF_Operation*) @nogc nothrow; 314 void TF_SetAttrString(TF_OperationDescription*, const(char)*, const(void)*, c_ulong) @nogc nothrow; 315 void TF_SetAttrStringList(TF_OperationDescription*, const(char)*, const(const(void)*)*, const(c_ulong)*, int) @nogc nothrow; 316 void TF_SetAttrInt(TF_OperationDescription*, const(char)*, c_long) @nogc nothrow; 317 void TF_SetAttrIntList(TF_OperationDescription*, const(char)*, const(c_long)*, int) @nogc nothrow; 318 void TF_SetAttrFloat(TF_OperationDescription*, const(char)*, float) @nogc nothrow; 319 void TF_SetAttrFloatList(TF_OperationDescription*, const(char)*, const(float)*, int) @nogc nothrow; 320 void TF_SetAttrBool(TF_OperationDescription*, const(char)*, ubyte) @nogc nothrow; 321 void TF_SetAttrBoolList(TF_OperationDescription*, const(char)*, const(ubyte)*, int) @nogc nothrow; 322 void TF_SetAttrType(TF_OperationDescription*, const(char)*, TF_DataType) @nogc nothrow; 323 void TF_SetAttrTypeList(TF_OperationDescription*, const(char)*, const(TF_DataType)*, int) @nogc nothrow; 324 void TF_SetAttrPlaceholder(TF_OperationDescription*, const(char)*, const(char)*) @nogc nothrow; 325 void TF_SetAttrFuncName(TF_OperationDescription*, const(char)*, const(char)*, c_ulong) @nogc nothrow; 326 void TF_SetAttrShape(TF_OperationDescription*, const(char)*, const(c_long)*, int) @nogc nothrow; 327 void TF_SetAttrShapeList(TF_OperationDescription*, const(char)*, const(const(c_long)*)*, const(int)*, int) @nogc nothrow; 328 void TF_SetAttrTensorShapeProto(TF_OperationDescription*, const(char)*, const(void)*, c_ulong, TF_Status*) @nogc nothrow; 329 void TF_SetAttrTensorShapeProtoList(TF_OperationDescription*, const(char)*, const(const(void)*)*, const(c_ulong)*, int, TF_Status*) @nogc nothrow; 330 void TF_SetAttrTensor(TF_OperationDescription*, const(char)*, TF_Tensor*, TF_Status*) @nogc nothrow; 331 void TF_SetAttrTensorList(TF_OperationDescription*, const(char)*, TF_Tensor**, int, TF_Status*) @nogc nothrow; 332 void TF_SetAttrValueProto(TF_OperationDescription*, const(char)*, const(void)*, c_ulong, TF_Status*) @nogc nothrow; 333 TF_Operation* TF_FinishOperation(TF_OperationDescription*, TF_Status*) @nogc nothrow; 334 const(char)* TF_OperationName(TF_Operation*) @nogc nothrow; 335 const(char)* TF_OperationOpType(TF_Operation*) @nogc nothrow; 336 const(char)* TF_OperationDevice(TF_Operation*) @nogc nothrow; 337 int TF_OperationNumOutputs(TF_Operation*) @nogc nothrow; 338 TF_DataType TF_OperationOutputType(TF_Output) @nogc nothrow; 339 int TF_OperationOutputListLength(TF_Operation*, const(char)*, TF_Status*) @nogc nothrow; 340 int TF_OperationNumInputs(TF_Operation*) @nogc nothrow; 341 TF_DataType TF_OperationInputType(TF_Input) @nogc nothrow; 342 int TF_OperationInputListLength(TF_Operation*, const(char)*, TF_Status*) @nogc nothrow; 343 TF_Output TF_OperationInput(TF_Input) @nogc nothrow; 344 int TF_OperationOutputNumConsumers(TF_Output) @nogc nothrow; 345 int TF_OperationOutputConsumers(TF_Output, TF_Input*, int) @nogc nothrow; 346 int TF_OperationNumControlInputs(TF_Operation*) @nogc nothrow; 347 int TF_OperationGetControlInputs(TF_Operation*, TF_Operation**, int) @nogc nothrow; 348 int TF_OperationNumControlOutputs(TF_Operation*) @nogc nothrow; 349 int TF_OperationGetControlOutputs(TF_Operation*, TF_Operation**, int) @nogc nothrow; 350 struct TF_AttrMetadata 351 { 352 ubyte is_list; 353 c_long list_size; 354 TF_AttrType type; 355 c_long total_size; 356 } 357 TF_AttrMetadata TF_OperationGetAttrMetadata(TF_Operation*, const(char)*, TF_Status*) @nogc nothrow; 358 void TF_OperationGetAttrString(TF_Operation*, const(char)*, void*, c_ulong, TF_Status*) @nogc nothrow; 359 void TF_OperationGetAttrStringList(TF_Operation*, const(char)*, void**, c_ulong*, int, void*, c_ulong, TF_Status*) @nogc nothrow; 360 void TF_OperationGetAttrInt(TF_Operation*, const(char)*, c_long*, TF_Status*) @nogc nothrow; 361 void TF_OperationGetAttrIntList(TF_Operation*, const(char)*, c_long*, int, TF_Status*) @nogc nothrow; 362 void TF_OperationGetAttrFloat(TF_Operation*, const(char)*, float*, TF_Status*) @nogc nothrow; 363 void TF_OperationGetAttrFloatList(TF_Operation*, const(char)*, float*, int, TF_Status*) @nogc nothrow; 364 void TF_OperationGetAttrBool(TF_Operation*, const(char)*, ubyte*, TF_Status*) @nogc nothrow; 365 void TF_OperationGetAttrBoolList(TF_Operation*, const(char)*, ubyte*, int, TF_Status*) @nogc nothrow; 366 void TF_OperationGetAttrType(TF_Operation*, const(char)*, TF_DataType*, TF_Status*) @nogc nothrow; 367 void TF_OperationGetAttrTypeList(TF_Operation*, const(char)*, TF_DataType*, int, TF_Status*) @nogc nothrow; 368 void TF_OperationGetAttrShape(TF_Operation*, const(char)*, c_long*, int, TF_Status*) @nogc nothrow; 369 void TF_OperationGetAttrShapeList(TF_Operation*, const(char)*, c_long**, int*, int, c_long*, int, TF_Status*) @nogc nothrow; 370 void TF_OperationGetAttrTensorShapeProto(TF_Operation*, const(char)*, TF_Buffer*, TF_Status*) @nogc nothrow; 371 void TF_OperationGetAttrTensorShapeProtoList(TF_Operation*, const(char)*, TF_Buffer**, int, TF_Status*) @nogc nothrow; 372 void TF_OperationGetAttrTensor(TF_Operation*, const(char)*, TF_Tensor**, TF_Status*) @nogc nothrow; 373 void TF_OperationGetAttrTensorList(TF_Operation*, const(char)*, TF_Tensor**, int, TF_Status*) @nogc nothrow; 374 void TF_OperationGetAttrValueProto(TF_Operation*, const(char)*, TF_Buffer*, TF_Status*) @nogc nothrow; 375 TF_Operation* TF_GraphOperationByName(TF_Graph*, const(char)*) @nogc nothrow; 376 TF_Operation* TF_GraphNextOperation(TF_Graph*, c_ulong*) @nogc nothrow; 377 void TF_GraphToGraphDef(TF_Graph*, TF_Buffer*, TF_Status*) @nogc nothrow; 378 void TF_GraphGetOpDef(TF_Graph*, const(char)*, TF_Buffer*, TF_Status*) @nogc nothrow; 379 void TF_GraphVersions(TF_Graph*, TF_Buffer*, TF_Status*) @nogc nothrow; 380 struct TF_ImportGraphDefOptions; 381 TF_ImportGraphDefOptions* TF_NewImportGraphDefOptions() @nogc nothrow; 382 void TF_DeleteImportGraphDefOptions(TF_ImportGraphDefOptions*) @nogc nothrow; 383 void TF_ImportGraphDefOptionsSetPrefix(TF_ImportGraphDefOptions*, const(char)*) @nogc nothrow; 384 void TF_ImportGraphDefOptionsSetDefaultDevice(TF_ImportGraphDefOptions*, const(char)*) @nogc nothrow; 385 void TF_ImportGraphDefOptionsSetUniquifyNames(TF_ImportGraphDefOptions*, ubyte) @nogc nothrow; 386 void TF_ImportGraphDefOptionsSetUniquifyPrefix(TF_ImportGraphDefOptions*, ubyte) @nogc nothrow; 387 void TF_ImportGraphDefOptionsAddInputMapping(TF_ImportGraphDefOptions*, const(char)*, int, TF_Output) @nogc nothrow; 388 void TF_ImportGraphDefOptionsRemapControlDependency(TF_ImportGraphDefOptions*, const(char)*, TF_Operation*) @nogc nothrow; 389 void TF_ImportGraphDefOptionsAddControlDependency(TF_ImportGraphDefOptions*, TF_Operation*) @nogc nothrow; 390 void TF_ImportGraphDefOptionsAddReturnOutput(TF_ImportGraphDefOptions*, const(char)*, int) @nogc nothrow; 391 int TF_ImportGraphDefOptionsNumReturnOutputs(const(TF_ImportGraphDefOptions)*) @nogc nothrow; 392 void TF_ImportGraphDefOptionsAddReturnOperation(TF_ImportGraphDefOptions*, const(char)*) @nogc nothrow; 393 int TF_ImportGraphDefOptionsNumReturnOperations(const(TF_ImportGraphDefOptions)*) @nogc nothrow; 394 struct TF_ImportGraphDefResults; 395 void TF_ImportGraphDefResultsReturnOutputs(TF_ImportGraphDefResults*, int*, TF_Output**) @nogc nothrow; 396 void TF_ImportGraphDefResultsReturnOperations(TF_ImportGraphDefResults*, int*, TF_Operation***) @nogc nothrow; 397 void TF_ImportGraphDefResultsMissingUnusedInputMappings(TF_ImportGraphDefResults*, int*, const(char)***, int**) @nogc nothrow; 398 void TF_DeleteImportGraphDefResults(TF_ImportGraphDefResults*) @nogc nothrow; 399 TF_ImportGraphDefResults* TF_GraphImportGraphDefWithResults(TF_Graph*, const(TF_Buffer)*, const(TF_ImportGraphDefOptions)*, TF_Status*) @nogc nothrow; 400 void TF_GraphImportGraphDefWithReturnOutputs(TF_Graph*, const(TF_Buffer)*, const(TF_ImportGraphDefOptions)*, TF_Output*, int, TF_Status*) @nogc nothrow; 401 void TF_GraphImportGraphDef(TF_Graph*, const(TF_Buffer)*, const(TF_ImportGraphDefOptions)*, TF_Status*) @nogc nothrow; 402 void TF_GraphCopyFunction(TF_Graph*, const(TF_Function)*, const(TF_Function)*, TF_Status*) @nogc nothrow; 403 int TF_GraphNumFunctions(TF_Graph*) @nogc nothrow; 404 int TF_GraphGetFunctions(TF_Graph*, TF_Function**, int, TF_Status*) @nogc nothrow; 405 void TF_OperationToNodeDef(TF_Operation*, TF_Buffer*, TF_Status*) @nogc nothrow; 406 struct TF_WhileParams 407 { 408 const(int) ninputs; 409 TF_Graph* cond_graph; 410 const(const(TF_Output)*) cond_inputs; 411 TF_Output cond_output; 412 TF_Graph* body_graph; 413 const(const(TF_Output)*) body_inputs; 414 TF_Output* body_outputs; 415 const(char)* name; 416 } 417 TF_WhileParams TF_NewWhile(TF_Graph*, TF_Output*, int, TF_Status*) @nogc nothrow; 418 void TF_FinishWhile(const(TF_WhileParams)*, TF_Status*, TF_Output*) @nogc nothrow; 419 void TF_AbortWhile(const(TF_WhileParams)*) @nogc nothrow; 420 void TF_AddGradients(TF_Graph*, TF_Output*, int, TF_Output*, int, TF_Output*, TF_Status*, TF_Output*) @nogc nothrow; 421 void TF_AddGradientsWithPrefix(TF_Graph*, const(char)*, TF_Output*, int, TF_Output*, int, TF_Output*, TF_Status*, TF_Output*) @nogc nothrow; 422 TF_Function* TF_GraphToFunction(const(TF_Graph)*, const(char)*, ubyte, int, const(const(TF_Operation)*)*, int, const(TF_Output)*, int, const(TF_Output)*, const(const(char)*)*, const(TF_FunctionOptions)*, const(char)*, TF_Status*) @nogc nothrow; 423 TF_Function* TF_GraphToFunctionWithControlOutputs(const(TF_Graph)*, const(char)*, ubyte, int, const(const(TF_Operation)*)*, int, const(TF_Output)*, int, const(TF_Output)*, const(const(char)*)*, int, const(const(TF_Operation)*)*, const(const(char)*)*, const(TF_FunctionOptions)*, const(char)*, TF_Status*) @nogc nothrow; 424 const(char)* TF_FunctionName(TF_Function*) @nogc nothrow; 425 void TF_FunctionToFunctionDef(TF_Function*, TF_Buffer*, TF_Status*) @nogc nothrow; 426 TF_Function* TF_FunctionImportFunctionDef(const(void)*, c_ulong, TF_Status*) @nogc nothrow; 427 void TF_FunctionSetAttrValueProto(TF_Function*, const(char)*, const(void)*, c_ulong, TF_Status*) @nogc nothrow; 428 void TF_FunctionGetAttrValueProto(TF_Function*, const(char)*, TF_Buffer*, TF_Status*) @nogc nothrow; 429 void TF_DeleteFunction(TF_Function*) @nogc nothrow; 430 ubyte TF_TryEvaluateConstant(TF_Graph*, TF_Output, TF_Tensor**, TF_Status*) @nogc nothrow; 431 struct TF_Session; 432 TF_Session* TF_NewSession(TF_Graph*, const(TF_SessionOptions)*, TF_Status*) @nogc nothrow; 433 TF_Session* TF_LoadSessionFromSavedModel(const(TF_SessionOptions)*, const(TF_Buffer)*, const(char)*, const(const(char)*)*, int, TF_Graph*, TF_Buffer*, TF_Status*) @nogc nothrow; 434 void TF_CloseSession(TF_Session*, TF_Status*) @nogc nothrow; 435 void TF_DeleteSession(TF_Session*, TF_Status*) @nogc nothrow; 436 void TF_SessionRun(TF_Session*, const(TF_Buffer)*, const(TF_Output)*, TF_Tensor**, int, const(TF_Output)*, TF_Tensor**, int, const(const(TF_Operation)*)*, int, TF_Buffer*, TF_Status*) @nogc nothrow; 437 void TF_SessionPRunSetup(TF_Session*, const(TF_Output)*, int, const(TF_Output)*, int, const(const(TF_Operation)*)*, int, const(char)**, TF_Status*) @nogc nothrow; 438 void TF_SessionPRun(TF_Session*, const(char)*, const(TF_Output)*, TF_Tensor**, int, const(TF_Output)*, TF_Tensor**, int, const(const(TF_Operation)*)*, int, TF_Status*) @nogc nothrow; 439 void TF_DeletePRunHandle(const(char)*) @nogc nothrow; 440 struct TF_DeprecatedSession; 441 TF_DeprecatedSession* TF_NewDeprecatedSession(const(TF_SessionOptions)*, TF_Status*) @nogc nothrow; 442 void TF_CloseDeprecatedSession(TF_DeprecatedSession*, TF_Status*) @nogc nothrow; 443 void TF_DeleteDeprecatedSession(TF_DeprecatedSession*, TF_Status*) @nogc nothrow; 444 void TF_Reset(const(TF_SessionOptions)*, const(char)**, int, TF_Status*) @nogc nothrow; 445 void TF_ExtendGraph(TF_DeprecatedSession*, const(void)*, c_ulong, TF_Status*) @nogc nothrow; 446 void TF_Run(TF_DeprecatedSession*, const(TF_Buffer)*, const(char)**, TF_Tensor**, int, const(char)**, TF_Tensor**, int, const(char)**, int, TF_Buffer*, TF_Status*) @nogc nothrow; 447 void TF_PRunSetup(TF_DeprecatedSession*, const(char)**, int, const(char)**, int, const(char)**, int, const(char)**, TF_Status*) @nogc nothrow; 448 void TF_PRun(TF_DeprecatedSession*, const(char)*, const(char)**, TF_Tensor**, int, const(char)**, TF_Tensor**, int, const(char)**, int, TF_Status*) @nogc nothrow; 449 struct TF_DeviceList; 450 TF_DeviceList* TF_SessionListDevices(TF_Session*, TF_Status*) @nogc nothrow; 451 TF_DeviceList* TF_DeprecatedSessionListDevices(TF_DeprecatedSession*, TF_Status*) @nogc nothrow; 452 void TF_DeleteDeviceList(TF_DeviceList*) @nogc nothrow; 453 int TF_DeviceListCount(const(TF_DeviceList)*) @nogc nothrow; 454 const(char)* TF_DeviceListName(const(TF_DeviceList)*, int, TF_Status*) @nogc nothrow; 455 const(char)* TF_DeviceListType(const(TF_DeviceList)*, int, TF_Status*) @nogc nothrow; 456 c_long TF_DeviceListMemoryBytes(const(TF_DeviceList)*, int, TF_Status*) @nogc nothrow; 457 c_ulong TF_DeviceListIncarnation(const(TF_DeviceList)*, int, TF_Status*) @nogc nothrow; 458 struct TF_Library; 459 TF_Library* TF_LoadLibrary(const(char)*, TF_Status*) @nogc nothrow; 460 TF_Buffer TF_GetOpList(TF_Library*) @nogc nothrow; 461 void TF_DeleteLibraryHandle(TF_Library*) @nogc nothrow; 462 TF_Buffer* TF_GetAllOpList() @nogc nothrow; 463 struct TF_ApiDefMap; 464 TF_ApiDefMap* TF_NewApiDefMap(TF_Buffer*, TF_Status*) @nogc nothrow; 465 void TF_DeleteApiDefMap(TF_ApiDefMap*) @nogc nothrow; 466 void TF_ApiDefMapPut(TF_ApiDefMap*, const(char)*, c_ulong, TF_Status*) @nogc nothrow; 467 TF_Buffer* TF_ApiDefMapGet(TF_ApiDefMap*, const(char)*, c_ulong, TF_Status*) @nogc nothrow; 468 TF_Buffer* TF_GetAllRegisteredKernels(TF_Status*) @nogc nothrow; 469 TF_Buffer* TF_GetRegisteredKernelsForOp(const(char)*, TF_Status*) @nogc nothrow; 470 struct TF_Server; 471 TF_Server* TF_NewServer(const(void)*, c_ulong, TF_Status*) @nogc nothrow; 472 void TF_ServerStart(TF_Server*, TF_Status*) @nogc nothrow; 473 void TF_ServerStop(TF_Server*, TF_Status*) @nogc nothrow; 474 void TF_ServerJoin(TF_Server*, TF_Status*) @nogc nothrow; 475 const(char)* TF_ServerTarget(TF_Server*) @nogc nothrow; 476 void TF_DeleteServer(TF_Server*) @nogc nothrow; 477 void TF_RegisterLogListener(void function(const(char)*)) @nogc nothrow; 478 struct max_align_t 479 { 480 long __clang_max_align_nonce1; 481 real __clang_max_align_nonce2; 482 } 483 alias ptrdiff_t = c_long; 484 alias size_t = c_ulong; 485 alias wchar_t = int; 486 487 488 489 static if(!is(typeof(NULL))) { 490 private enum enumMixinStr_NULL = `enum NULL = ( cast( void * ) 0 );`; 491 static if(is(typeof({ mixin(enumMixinStr_NULL); }))) { 492 mixin(enumMixinStr_NULL); 493 } 494 } 495 static if(!is(typeof(_FEATURES_H))) { 496 private enum enumMixinStr__FEATURES_H = `enum _FEATURES_H = 1;`; 497 static if(is(typeof({ mixin(enumMixinStr__FEATURES_H); }))) { 498 mixin(enumMixinStr__FEATURES_H); 499 } 500 } 501 static if(!is(typeof(__bool_true_false_are_defined))) { 502 private enum enumMixinStr___bool_true_false_are_defined = `enum __bool_true_false_are_defined = 1;`; 503 static if(is(typeof({ mixin(enumMixinStr___bool_true_false_are_defined); }))) { 504 mixin(enumMixinStr___bool_true_false_are_defined); 505 } 506 } 507 508 509 510 511 static if(!is(typeof(false_))) { 512 private enum enumMixinStr_false_ = `enum false_ = 0;`; 513 static if(is(typeof({ mixin(enumMixinStr_false_); }))) { 514 mixin(enumMixinStr_false_); 515 } 516 } 517 static if(!is(typeof(_DEFAULT_SOURCE))) { 518 private enum enumMixinStr__DEFAULT_SOURCE = `enum _DEFAULT_SOURCE = 1;`; 519 static if(is(typeof({ mixin(enumMixinStr__DEFAULT_SOURCE); }))) { 520 mixin(enumMixinStr__DEFAULT_SOURCE); 521 } 522 } 523 524 525 526 527 static if(!is(typeof(true_))) { 528 private enum enumMixinStr_true_ = `enum true_ = 1;`; 529 static if(is(typeof({ mixin(enumMixinStr_true_); }))) { 530 mixin(enumMixinStr_true_); 531 } 532 } 533 534 535 536 537 static if(!is(typeof(bool_))) { 538 private enum enumMixinStr_bool_ = `enum bool_ = _Bool;`; 539 static if(is(typeof({ mixin(enumMixinStr_bool_); }))) { 540 mixin(enumMixinStr_bool_); 541 } 542 } 543 544 545 546 547 static if(!is(typeof(__USE_ISOC11))) { 548 private enum enumMixinStr___USE_ISOC11 = `enum __USE_ISOC11 = 1;`; 549 static if(is(typeof({ mixin(enumMixinStr___USE_ISOC11); }))) { 550 mixin(enumMixinStr___USE_ISOC11); 551 } 552 } 553 static if(!is(typeof(__USE_ISOC99))) { 554 private enum enumMixinStr___USE_ISOC99 = `enum __USE_ISOC99 = 1;`; 555 static if(is(typeof({ mixin(enumMixinStr___USE_ISOC99); }))) { 556 mixin(enumMixinStr___USE_ISOC99); 557 } 558 } 559 560 561 562 563 static if(!is(typeof(TF_CAPI_EXPORT))) { 564 private enum enumMixinStr_TF_CAPI_EXPORT = `enum TF_CAPI_EXPORT = __attribute__ ( ( visibility ( "default" ) ) );`; 565 static if(is(typeof({ mixin(enumMixinStr_TF_CAPI_EXPORT); }))) { 566 mixin(enumMixinStr_TF_CAPI_EXPORT); 567 } 568 } 569 570 571 572 573 574 575 static if(!is(typeof(__USE_ISOC95))) { 576 private enum enumMixinStr___USE_ISOC95 = `enum __USE_ISOC95 = 1;`; 577 static if(is(typeof({ mixin(enumMixinStr___USE_ISOC95); }))) { 578 mixin(enumMixinStr___USE_ISOC95); 579 } 580 } 581 582 583 584 585 static if(!is(typeof(__USE_POSIX_IMPLICITLY))) { 586 private enum enumMixinStr___USE_POSIX_IMPLICITLY = `enum __USE_POSIX_IMPLICITLY = 1;`; 587 static if(is(typeof({ mixin(enumMixinStr___USE_POSIX_IMPLICITLY); }))) { 588 mixin(enumMixinStr___USE_POSIX_IMPLICITLY); 589 } 590 } 591 592 593 594 595 static if(!is(typeof(_POSIX_SOURCE))) { 596 private enum enumMixinStr__POSIX_SOURCE = `enum _POSIX_SOURCE = 1;`; 597 static if(is(typeof({ mixin(enumMixinStr__POSIX_SOURCE); }))) { 598 mixin(enumMixinStr__POSIX_SOURCE); 599 } 600 } 601 602 603 604 605 static if(!is(typeof(_POSIX_C_SOURCE))) { 606 private enum enumMixinStr__POSIX_C_SOURCE = `enum _POSIX_C_SOURCE = 200809L;`; 607 static if(is(typeof({ mixin(enumMixinStr__POSIX_C_SOURCE); }))) { 608 mixin(enumMixinStr__POSIX_C_SOURCE); 609 } 610 } 611 612 613 614 615 static if(!is(typeof(__USE_POSIX))) { 616 private enum enumMixinStr___USE_POSIX = `enum __USE_POSIX = 1;`; 617 static if(is(typeof({ mixin(enumMixinStr___USE_POSIX); }))) { 618 mixin(enumMixinStr___USE_POSIX); 619 } 620 } 621 622 623 624 625 static if(!is(typeof(__USE_POSIX2))) { 626 private enum enumMixinStr___USE_POSIX2 = `enum __USE_POSIX2 = 1;`; 627 static if(is(typeof({ mixin(enumMixinStr___USE_POSIX2); }))) { 628 mixin(enumMixinStr___USE_POSIX2); 629 } 630 } 631 632 633 634 635 static if(!is(typeof(__USE_POSIX199309))) { 636 private enum enumMixinStr___USE_POSIX199309 = `enum __USE_POSIX199309 = 1;`; 637 static if(is(typeof({ mixin(enumMixinStr___USE_POSIX199309); }))) { 638 mixin(enumMixinStr___USE_POSIX199309); 639 } 640 } 641 642 643 644 645 static if(!is(typeof(__USE_POSIX199506))) { 646 private enum enumMixinStr___USE_POSIX199506 = `enum __USE_POSIX199506 = 1;`; 647 static if(is(typeof({ mixin(enumMixinStr___USE_POSIX199506); }))) { 648 mixin(enumMixinStr___USE_POSIX199506); 649 } 650 } 651 652 653 654 655 static if(!is(typeof(__USE_XOPEN2K))) { 656 private enum enumMixinStr___USE_XOPEN2K = `enum __USE_XOPEN2K = 1;`; 657 static if(is(typeof({ mixin(enumMixinStr___USE_XOPEN2K); }))) { 658 mixin(enumMixinStr___USE_XOPEN2K); 659 } 660 } 661 662 663 664 665 static if(!is(typeof(__USE_XOPEN2K8))) { 666 private enum enumMixinStr___USE_XOPEN2K8 = `enum __USE_XOPEN2K8 = 1;`; 667 static if(is(typeof({ mixin(enumMixinStr___USE_XOPEN2K8); }))) { 668 mixin(enumMixinStr___USE_XOPEN2K8); 669 } 670 } 671 672 673 674 675 static if(!is(typeof(_ATFILE_SOURCE))) { 676 private enum enumMixinStr__ATFILE_SOURCE = `enum _ATFILE_SOURCE = 1;`; 677 static if(is(typeof({ mixin(enumMixinStr__ATFILE_SOURCE); }))) { 678 mixin(enumMixinStr__ATFILE_SOURCE); 679 } 680 } 681 682 683 684 685 static if(!is(typeof(__USE_MISC))) { 686 private enum enumMixinStr___USE_MISC = `enum __USE_MISC = 1;`; 687 static if(is(typeof({ mixin(enumMixinStr___USE_MISC); }))) { 688 mixin(enumMixinStr___USE_MISC); 689 } 690 } 691 692 693 694 695 static if(!is(typeof(__USE_ATFILE))) { 696 private enum enumMixinStr___USE_ATFILE = `enum __USE_ATFILE = 1;`; 697 static if(is(typeof({ mixin(enumMixinStr___USE_ATFILE); }))) { 698 mixin(enumMixinStr___USE_ATFILE); 699 } 700 } 701 702 703 704 705 static if(!is(typeof(__USE_FORTIFY_LEVEL))) { 706 private enum enumMixinStr___USE_FORTIFY_LEVEL = `enum __USE_FORTIFY_LEVEL = 0;`; 707 static if(is(typeof({ mixin(enumMixinStr___USE_FORTIFY_LEVEL); }))) { 708 mixin(enumMixinStr___USE_FORTIFY_LEVEL); 709 } 710 } 711 712 713 714 715 static if(!is(typeof(__GLIBC_USE_DEPRECATED_GETS))) { 716 private enum enumMixinStr___GLIBC_USE_DEPRECATED_GETS = `enum __GLIBC_USE_DEPRECATED_GETS = 0;`; 717 static if(is(typeof({ mixin(enumMixinStr___GLIBC_USE_DEPRECATED_GETS); }))) { 718 mixin(enumMixinStr___GLIBC_USE_DEPRECATED_GETS); 719 } 720 } 721 722 723 724 725 static if(!is(typeof(__GNU_LIBRARY__))) { 726 private enum enumMixinStr___GNU_LIBRARY__ = `enum __GNU_LIBRARY__ = 6;`; 727 static if(is(typeof({ mixin(enumMixinStr___GNU_LIBRARY__); }))) { 728 mixin(enumMixinStr___GNU_LIBRARY__); 729 } 730 } 731 732 733 734 735 static if(!is(typeof(__GLIBC__))) { 736 private enum enumMixinStr___GLIBC__ = `enum __GLIBC__ = 2;`; 737 static if(is(typeof({ mixin(enumMixinStr___GLIBC__); }))) { 738 mixin(enumMixinStr___GLIBC__); 739 } 740 } 741 742 743 744 745 static if(!is(typeof(__GLIBC_MINOR__))) { 746 private enum enumMixinStr___GLIBC_MINOR__ = `enum __GLIBC_MINOR__ = 27;`; 747 static if(is(typeof({ mixin(enumMixinStr___GLIBC_MINOR__); }))) { 748 mixin(enumMixinStr___GLIBC_MINOR__); 749 } 750 } 751 752 753 754 755 756 757 static if(!is(typeof(_STDC_PREDEF_H))) { 758 private enum enumMixinStr__STDC_PREDEF_H = `enum _STDC_PREDEF_H = 1;`; 759 static if(is(typeof({ mixin(enumMixinStr__STDC_PREDEF_H); }))) { 760 mixin(enumMixinStr__STDC_PREDEF_H); 761 } 762 } 763 764 765 766 767 static if(!is(typeof(_STDINT_H))) { 768 private enum enumMixinStr__STDINT_H = `enum _STDINT_H = 1;`; 769 static if(is(typeof({ mixin(enumMixinStr__STDINT_H); }))) { 770 mixin(enumMixinStr__STDINT_H); 771 } 772 } 773 static if(!is(typeof(INT8_MIN))) { 774 private enum enumMixinStr_INT8_MIN = `enum INT8_MIN = ( - 128 );`; 775 static if(is(typeof({ mixin(enumMixinStr_INT8_MIN); }))) { 776 mixin(enumMixinStr_INT8_MIN); 777 } 778 } 779 780 781 782 783 static if(!is(typeof(INT16_MIN))) { 784 private enum enumMixinStr_INT16_MIN = `enum INT16_MIN = ( - 32767 - 1 );`; 785 static if(is(typeof({ mixin(enumMixinStr_INT16_MIN); }))) { 786 mixin(enumMixinStr_INT16_MIN); 787 } 788 } 789 790 791 792 793 static if(!is(typeof(INT32_MIN))) { 794 private enum enumMixinStr_INT32_MIN = `enum INT32_MIN = ( - 2147483647 - 1 );`; 795 static if(is(typeof({ mixin(enumMixinStr_INT32_MIN); }))) { 796 mixin(enumMixinStr_INT32_MIN); 797 } 798 } 799 800 801 802 803 static if(!is(typeof(INT64_MIN))) { 804 private enum enumMixinStr_INT64_MIN = `enum INT64_MIN = ( - 9223372036854775807L - 1 );`; 805 static if(is(typeof({ mixin(enumMixinStr_INT64_MIN); }))) { 806 mixin(enumMixinStr_INT64_MIN); 807 } 808 } 809 810 811 812 813 static if(!is(typeof(INT8_MAX))) { 814 private enum enumMixinStr_INT8_MAX = `enum INT8_MAX = ( 127 );`; 815 static if(is(typeof({ mixin(enumMixinStr_INT8_MAX); }))) { 816 mixin(enumMixinStr_INT8_MAX); 817 } 818 } 819 820 821 822 823 static if(!is(typeof(INT16_MAX))) { 824 private enum enumMixinStr_INT16_MAX = `enum INT16_MAX = ( 32767 );`; 825 static if(is(typeof({ mixin(enumMixinStr_INT16_MAX); }))) { 826 mixin(enumMixinStr_INT16_MAX); 827 } 828 } 829 830 831 832 833 static if(!is(typeof(INT32_MAX))) { 834 private enum enumMixinStr_INT32_MAX = `enum INT32_MAX = ( 2147483647 );`; 835 static if(is(typeof({ mixin(enumMixinStr_INT32_MAX); }))) { 836 mixin(enumMixinStr_INT32_MAX); 837 } 838 } 839 840 841 842 843 static if(!is(typeof(INT64_MAX))) { 844 private enum enumMixinStr_INT64_MAX = `enum INT64_MAX = ( 9223372036854775807L );`; 845 static if(is(typeof({ mixin(enumMixinStr_INT64_MAX); }))) { 846 mixin(enumMixinStr_INT64_MAX); 847 } 848 } 849 850 851 852 853 static if(!is(typeof(UINT8_MAX))) { 854 private enum enumMixinStr_UINT8_MAX = `enum UINT8_MAX = ( 255 );`; 855 static if(is(typeof({ mixin(enumMixinStr_UINT8_MAX); }))) { 856 mixin(enumMixinStr_UINT8_MAX); 857 } 858 } 859 860 861 862 863 static if(!is(typeof(UINT16_MAX))) { 864 private enum enumMixinStr_UINT16_MAX = `enum UINT16_MAX = ( 65535 );`; 865 static if(is(typeof({ mixin(enumMixinStr_UINT16_MAX); }))) { 866 mixin(enumMixinStr_UINT16_MAX); 867 } 868 } 869 870 871 872 873 static if(!is(typeof(UINT32_MAX))) { 874 private enum enumMixinStr_UINT32_MAX = `enum UINT32_MAX = ( 4294967295U );`; 875 static if(is(typeof({ mixin(enumMixinStr_UINT32_MAX); }))) { 876 mixin(enumMixinStr_UINT32_MAX); 877 } 878 } 879 880 881 882 883 static if(!is(typeof(UINT64_MAX))) { 884 private enum enumMixinStr_UINT64_MAX = `enum UINT64_MAX = ( 18446744073709551615UL );`; 885 static if(is(typeof({ mixin(enumMixinStr_UINT64_MAX); }))) { 886 mixin(enumMixinStr_UINT64_MAX); 887 } 888 } 889 890 891 892 893 static if(!is(typeof(INT_LEAST8_MIN))) { 894 private enum enumMixinStr_INT_LEAST8_MIN = `enum INT_LEAST8_MIN = ( - 128 );`; 895 static if(is(typeof({ mixin(enumMixinStr_INT_LEAST8_MIN); }))) { 896 mixin(enumMixinStr_INT_LEAST8_MIN); 897 } 898 } 899 900 901 902 903 static if(!is(typeof(INT_LEAST16_MIN))) { 904 private enum enumMixinStr_INT_LEAST16_MIN = `enum INT_LEAST16_MIN = ( - 32767 - 1 );`; 905 static if(is(typeof({ mixin(enumMixinStr_INT_LEAST16_MIN); }))) { 906 mixin(enumMixinStr_INT_LEAST16_MIN); 907 } 908 } 909 910 911 912 913 static if(!is(typeof(INT_LEAST32_MIN))) { 914 private enum enumMixinStr_INT_LEAST32_MIN = `enum INT_LEAST32_MIN = ( - 2147483647 - 1 );`; 915 static if(is(typeof({ mixin(enumMixinStr_INT_LEAST32_MIN); }))) { 916 mixin(enumMixinStr_INT_LEAST32_MIN); 917 } 918 } 919 920 921 922 923 static if(!is(typeof(INT_LEAST64_MIN))) { 924 private enum enumMixinStr_INT_LEAST64_MIN = `enum INT_LEAST64_MIN = ( - 9223372036854775807L - 1 );`; 925 static if(is(typeof({ mixin(enumMixinStr_INT_LEAST64_MIN); }))) { 926 mixin(enumMixinStr_INT_LEAST64_MIN); 927 } 928 } 929 930 931 932 933 static if(!is(typeof(INT_LEAST8_MAX))) { 934 private enum enumMixinStr_INT_LEAST8_MAX = `enum INT_LEAST8_MAX = ( 127 );`; 935 static if(is(typeof({ mixin(enumMixinStr_INT_LEAST8_MAX); }))) { 936 mixin(enumMixinStr_INT_LEAST8_MAX); 937 } 938 } 939 940 941 942 943 static if(!is(typeof(INT_LEAST16_MAX))) { 944 private enum enumMixinStr_INT_LEAST16_MAX = `enum INT_LEAST16_MAX = ( 32767 );`; 945 static if(is(typeof({ mixin(enumMixinStr_INT_LEAST16_MAX); }))) { 946 mixin(enumMixinStr_INT_LEAST16_MAX); 947 } 948 } 949 950 951 952 953 static if(!is(typeof(INT_LEAST32_MAX))) { 954 private enum enumMixinStr_INT_LEAST32_MAX = `enum INT_LEAST32_MAX = ( 2147483647 );`; 955 static if(is(typeof({ mixin(enumMixinStr_INT_LEAST32_MAX); }))) { 956 mixin(enumMixinStr_INT_LEAST32_MAX); 957 } 958 } 959 960 961 962 963 static if(!is(typeof(INT_LEAST64_MAX))) { 964 private enum enumMixinStr_INT_LEAST64_MAX = `enum INT_LEAST64_MAX = ( 9223372036854775807L );`; 965 static if(is(typeof({ mixin(enumMixinStr_INT_LEAST64_MAX); }))) { 966 mixin(enumMixinStr_INT_LEAST64_MAX); 967 } 968 } 969 970 971 972 973 static if(!is(typeof(UINT_LEAST8_MAX))) { 974 private enum enumMixinStr_UINT_LEAST8_MAX = `enum UINT_LEAST8_MAX = ( 255 );`; 975 static if(is(typeof({ mixin(enumMixinStr_UINT_LEAST8_MAX); }))) { 976 mixin(enumMixinStr_UINT_LEAST8_MAX); 977 } 978 } 979 980 981 982 983 static if(!is(typeof(UINT_LEAST16_MAX))) { 984 private enum enumMixinStr_UINT_LEAST16_MAX = `enum UINT_LEAST16_MAX = ( 65535 );`; 985 static if(is(typeof({ mixin(enumMixinStr_UINT_LEAST16_MAX); }))) { 986 mixin(enumMixinStr_UINT_LEAST16_MAX); 987 } 988 } 989 990 991 992 993 static if(!is(typeof(UINT_LEAST32_MAX))) { 994 private enum enumMixinStr_UINT_LEAST32_MAX = `enum UINT_LEAST32_MAX = ( 4294967295U );`; 995 static if(is(typeof({ mixin(enumMixinStr_UINT_LEAST32_MAX); }))) { 996 mixin(enumMixinStr_UINT_LEAST32_MAX); 997 } 998 } 999 1000 1001 1002 1003 static if(!is(typeof(UINT_LEAST64_MAX))) { 1004 private enum enumMixinStr_UINT_LEAST64_MAX = `enum UINT_LEAST64_MAX = ( 18446744073709551615UL );`; 1005 static if(is(typeof({ mixin(enumMixinStr_UINT_LEAST64_MAX); }))) { 1006 mixin(enumMixinStr_UINT_LEAST64_MAX); 1007 } 1008 } 1009 1010 1011 1012 1013 static if(!is(typeof(INT_FAST8_MIN))) { 1014 private enum enumMixinStr_INT_FAST8_MIN = `enum INT_FAST8_MIN = ( - 128 );`; 1015 static if(is(typeof({ mixin(enumMixinStr_INT_FAST8_MIN); }))) { 1016 mixin(enumMixinStr_INT_FAST8_MIN); 1017 } 1018 } 1019 1020 1021 1022 1023 static if(!is(typeof(INT_FAST16_MIN))) { 1024 private enum enumMixinStr_INT_FAST16_MIN = `enum INT_FAST16_MIN = ( - 9223372036854775807L - 1 );`; 1025 static if(is(typeof({ mixin(enumMixinStr_INT_FAST16_MIN); }))) { 1026 mixin(enumMixinStr_INT_FAST16_MIN); 1027 } 1028 } 1029 1030 1031 1032 1033 static if(!is(typeof(INT_FAST32_MIN))) { 1034 private enum enumMixinStr_INT_FAST32_MIN = `enum INT_FAST32_MIN = ( - 9223372036854775807L - 1 );`; 1035 static if(is(typeof({ mixin(enumMixinStr_INT_FAST32_MIN); }))) { 1036 mixin(enumMixinStr_INT_FAST32_MIN); 1037 } 1038 } 1039 1040 1041 1042 1043 static if(!is(typeof(INT_FAST64_MIN))) { 1044 private enum enumMixinStr_INT_FAST64_MIN = `enum INT_FAST64_MIN = ( - 9223372036854775807L - 1 );`; 1045 static if(is(typeof({ mixin(enumMixinStr_INT_FAST64_MIN); }))) { 1046 mixin(enumMixinStr_INT_FAST64_MIN); 1047 } 1048 } 1049 1050 1051 1052 1053 static if(!is(typeof(INT_FAST8_MAX))) { 1054 private enum enumMixinStr_INT_FAST8_MAX = `enum INT_FAST8_MAX = ( 127 );`; 1055 static if(is(typeof({ mixin(enumMixinStr_INT_FAST8_MAX); }))) { 1056 mixin(enumMixinStr_INT_FAST8_MAX); 1057 } 1058 } 1059 1060 1061 1062 1063 static if(!is(typeof(INT_FAST16_MAX))) { 1064 private enum enumMixinStr_INT_FAST16_MAX = `enum INT_FAST16_MAX = ( 9223372036854775807L );`; 1065 static if(is(typeof({ mixin(enumMixinStr_INT_FAST16_MAX); }))) { 1066 mixin(enumMixinStr_INT_FAST16_MAX); 1067 } 1068 } 1069 1070 1071 1072 1073 static if(!is(typeof(INT_FAST32_MAX))) { 1074 private enum enumMixinStr_INT_FAST32_MAX = `enum INT_FAST32_MAX = ( 9223372036854775807L );`; 1075 static if(is(typeof({ mixin(enumMixinStr_INT_FAST32_MAX); }))) { 1076 mixin(enumMixinStr_INT_FAST32_MAX); 1077 } 1078 } 1079 1080 1081 1082 1083 static if(!is(typeof(INT_FAST64_MAX))) { 1084 private enum enumMixinStr_INT_FAST64_MAX = `enum INT_FAST64_MAX = ( 9223372036854775807L );`; 1085 static if(is(typeof({ mixin(enumMixinStr_INT_FAST64_MAX); }))) { 1086 mixin(enumMixinStr_INT_FAST64_MAX); 1087 } 1088 } 1089 1090 1091 1092 1093 static if(!is(typeof(UINT_FAST8_MAX))) { 1094 private enum enumMixinStr_UINT_FAST8_MAX = `enum UINT_FAST8_MAX = ( 255 );`; 1095 static if(is(typeof({ mixin(enumMixinStr_UINT_FAST8_MAX); }))) { 1096 mixin(enumMixinStr_UINT_FAST8_MAX); 1097 } 1098 } 1099 1100 1101 1102 1103 static if(!is(typeof(UINT_FAST16_MAX))) { 1104 private enum enumMixinStr_UINT_FAST16_MAX = `enum UINT_FAST16_MAX = ( 18446744073709551615UL );`; 1105 static if(is(typeof({ mixin(enumMixinStr_UINT_FAST16_MAX); }))) { 1106 mixin(enumMixinStr_UINT_FAST16_MAX); 1107 } 1108 } 1109 1110 1111 1112 1113 static if(!is(typeof(UINT_FAST32_MAX))) { 1114 private enum enumMixinStr_UINT_FAST32_MAX = `enum UINT_FAST32_MAX = ( 18446744073709551615UL );`; 1115 static if(is(typeof({ mixin(enumMixinStr_UINT_FAST32_MAX); }))) { 1116 mixin(enumMixinStr_UINT_FAST32_MAX); 1117 } 1118 } 1119 1120 1121 1122 1123 static if(!is(typeof(UINT_FAST64_MAX))) { 1124 private enum enumMixinStr_UINT_FAST64_MAX = `enum UINT_FAST64_MAX = ( 18446744073709551615UL );`; 1125 static if(is(typeof({ mixin(enumMixinStr_UINT_FAST64_MAX); }))) { 1126 mixin(enumMixinStr_UINT_FAST64_MAX); 1127 } 1128 } 1129 1130 1131 1132 1133 static if(!is(typeof(INTPTR_MIN))) { 1134 private enum enumMixinStr_INTPTR_MIN = `enum INTPTR_MIN = ( - 9223372036854775807L - 1 );`; 1135 static if(is(typeof({ mixin(enumMixinStr_INTPTR_MIN); }))) { 1136 mixin(enumMixinStr_INTPTR_MIN); 1137 } 1138 } 1139 1140 1141 1142 1143 static if(!is(typeof(INTPTR_MAX))) { 1144 private enum enumMixinStr_INTPTR_MAX = `enum INTPTR_MAX = ( 9223372036854775807L );`; 1145 static if(is(typeof({ mixin(enumMixinStr_INTPTR_MAX); }))) { 1146 mixin(enumMixinStr_INTPTR_MAX); 1147 } 1148 } 1149 1150 1151 1152 1153 static if(!is(typeof(UINTPTR_MAX))) { 1154 private enum enumMixinStr_UINTPTR_MAX = `enum UINTPTR_MAX = ( 18446744073709551615UL );`; 1155 static if(is(typeof({ mixin(enumMixinStr_UINTPTR_MAX); }))) { 1156 mixin(enumMixinStr_UINTPTR_MAX); 1157 } 1158 } 1159 1160 1161 1162 1163 static if(!is(typeof(INTMAX_MIN))) { 1164 private enum enumMixinStr_INTMAX_MIN = `enum INTMAX_MIN = ( - 9223372036854775807L - 1 );`; 1165 static if(is(typeof({ mixin(enumMixinStr_INTMAX_MIN); }))) { 1166 mixin(enumMixinStr_INTMAX_MIN); 1167 } 1168 } 1169 1170 1171 1172 1173 static if(!is(typeof(INTMAX_MAX))) { 1174 private enum enumMixinStr_INTMAX_MAX = `enum INTMAX_MAX = ( 9223372036854775807L );`; 1175 static if(is(typeof({ mixin(enumMixinStr_INTMAX_MAX); }))) { 1176 mixin(enumMixinStr_INTMAX_MAX); 1177 } 1178 } 1179 1180 1181 1182 1183 static if(!is(typeof(UINTMAX_MAX))) { 1184 private enum enumMixinStr_UINTMAX_MAX = `enum UINTMAX_MAX = ( 18446744073709551615UL );`; 1185 static if(is(typeof({ mixin(enumMixinStr_UINTMAX_MAX); }))) { 1186 mixin(enumMixinStr_UINTMAX_MAX); 1187 } 1188 } 1189 1190 1191 1192 1193 static if(!is(typeof(PTRDIFF_MIN))) { 1194 private enum enumMixinStr_PTRDIFF_MIN = `enum PTRDIFF_MIN = ( - 9223372036854775807L - 1 );`; 1195 static if(is(typeof({ mixin(enumMixinStr_PTRDIFF_MIN); }))) { 1196 mixin(enumMixinStr_PTRDIFF_MIN); 1197 } 1198 } 1199 1200 1201 1202 1203 static if(!is(typeof(PTRDIFF_MAX))) { 1204 private enum enumMixinStr_PTRDIFF_MAX = `enum PTRDIFF_MAX = ( 9223372036854775807L );`; 1205 static if(is(typeof({ mixin(enumMixinStr_PTRDIFF_MAX); }))) { 1206 mixin(enumMixinStr_PTRDIFF_MAX); 1207 } 1208 } 1209 1210 1211 1212 1213 static if(!is(typeof(SIG_ATOMIC_MIN))) { 1214 private enum enumMixinStr_SIG_ATOMIC_MIN = `enum SIG_ATOMIC_MIN = ( - 2147483647 - 1 );`; 1215 static if(is(typeof({ mixin(enumMixinStr_SIG_ATOMIC_MIN); }))) { 1216 mixin(enumMixinStr_SIG_ATOMIC_MIN); 1217 } 1218 } 1219 1220 1221 1222 1223 static if(!is(typeof(SIG_ATOMIC_MAX))) { 1224 private enum enumMixinStr_SIG_ATOMIC_MAX = `enum SIG_ATOMIC_MAX = ( 2147483647 );`; 1225 static if(is(typeof({ mixin(enumMixinStr_SIG_ATOMIC_MAX); }))) { 1226 mixin(enumMixinStr_SIG_ATOMIC_MAX); 1227 } 1228 } 1229 1230 1231 1232 1233 static if(!is(typeof(SIZE_MAX))) { 1234 private enum enumMixinStr_SIZE_MAX = `enum SIZE_MAX = ( 18446744073709551615UL );`; 1235 static if(is(typeof({ mixin(enumMixinStr_SIZE_MAX); }))) { 1236 mixin(enumMixinStr_SIZE_MAX); 1237 } 1238 } 1239 1240 1241 1242 1243 static if(!is(typeof(WCHAR_MIN))) { 1244 private enum enumMixinStr_WCHAR_MIN = `enum WCHAR_MIN = __WCHAR_MIN;`; 1245 static if(is(typeof({ mixin(enumMixinStr_WCHAR_MIN); }))) { 1246 mixin(enumMixinStr_WCHAR_MIN); 1247 } 1248 } 1249 1250 1251 1252 1253 static if(!is(typeof(WCHAR_MAX))) { 1254 private enum enumMixinStr_WCHAR_MAX = `enum WCHAR_MAX = __WCHAR_MAX;`; 1255 static if(is(typeof({ mixin(enumMixinStr_WCHAR_MAX); }))) { 1256 mixin(enumMixinStr_WCHAR_MAX); 1257 } 1258 } 1259 1260 1261 1262 1263 static if(!is(typeof(WINT_MIN))) { 1264 private enum enumMixinStr_WINT_MIN = `enum WINT_MIN = ( 0u );`; 1265 static if(is(typeof({ mixin(enumMixinStr_WINT_MIN); }))) { 1266 mixin(enumMixinStr_WINT_MIN); 1267 } 1268 } 1269 1270 1271 1272 1273 static if(!is(typeof(WINT_MAX))) { 1274 private enum enumMixinStr_WINT_MAX = `enum WINT_MAX = ( 4294967295u );`; 1275 static if(is(typeof({ mixin(enumMixinStr_WINT_MAX); }))) { 1276 mixin(enumMixinStr_WINT_MAX); 1277 } 1278 } 1279 static if(!is(typeof(__GLIBC_USE_LIB_EXT2))) { 1280 private enum enumMixinStr___GLIBC_USE_LIB_EXT2 = `enum __GLIBC_USE_LIB_EXT2 = 0;`; 1281 static if(is(typeof({ mixin(enumMixinStr___GLIBC_USE_LIB_EXT2); }))) { 1282 mixin(enumMixinStr___GLIBC_USE_LIB_EXT2); 1283 } 1284 } 1285 1286 1287 1288 1289 static if(!is(typeof(__GLIBC_USE_IEC_60559_BFP_EXT))) { 1290 private enum enumMixinStr___GLIBC_USE_IEC_60559_BFP_EXT = `enum __GLIBC_USE_IEC_60559_BFP_EXT = 0;`; 1291 static if(is(typeof({ mixin(enumMixinStr___GLIBC_USE_IEC_60559_BFP_EXT); }))) { 1292 mixin(enumMixinStr___GLIBC_USE_IEC_60559_BFP_EXT); 1293 } 1294 } 1295 1296 1297 1298 1299 static if(!is(typeof(__GLIBC_USE_IEC_60559_FUNCS_EXT))) { 1300 private enum enumMixinStr___GLIBC_USE_IEC_60559_FUNCS_EXT = `enum __GLIBC_USE_IEC_60559_FUNCS_EXT = 0;`; 1301 static if(is(typeof({ mixin(enumMixinStr___GLIBC_USE_IEC_60559_FUNCS_EXT); }))) { 1302 mixin(enumMixinStr___GLIBC_USE_IEC_60559_FUNCS_EXT); 1303 } 1304 } 1305 1306 1307 1308 1309 static if(!is(typeof(__GLIBC_USE_IEC_60559_TYPES_EXT))) { 1310 private enum enumMixinStr___GLIBC_USE_IEC_60559_TYPES_EXT = `enum __GLIBC_USE_IEC_60559_TYPES_EXT = 0;`; 1311 static if(is(typeof({ mixin(enumMixinStr___GLIBC_USE_IEC_60559_TYPES_EXT); }))) { 1312 mixin(enumMixinStr___GLIBC_USE_IEC_60559_TYPES_EXT); 1313 } 1314 } 1315 1316 1317 1318 1319 static if(!is(typeof(_BITS_STDINT_INTN_H))) { 1320 private enum enumMixinStr__BITS_STDINT_INTN_H = `enum _BITS_STDINT_INTN_H = 1;`; 1321 static if(is(typeof({ mixin(enumMixinStr__BITS_STDINT_INTN_H); }))) { 1322 mixin(enumMixinStr__BITS_STDINT_INTN_H); 1323 } 1324 } 1325 1326 1327 1328 1329 static if(!is(typeof(_BITS_STDINT_UINTN_H))) { 1330 private enum enumMixinStr__BITS_STDINT_UINTN_H = `enum _BITS_STDINT_UINTN_H = 1;`; 1331 static if(is(typeof({ mixin(enumMixinStr__BITS_STDINT_UINTN_H); }))) { 1332 mixin(enumMixinStr__BITS_STDINT_UINTN_H); 1333 } 1334 } 1335 1336 1337 1338 1339 static if(!is(typeof(_BITS_TYPES_H))) { 1340 private enum enumMixinStr__BITS_TYPES_H = `enum _BITS_TYPES_H = 1;`; 1341 static if(is(typeof({ mixin(enumMixinStr__BITS_TYPES_H); }))) { 1342 mixin(enumMixinStr__BITS_TYPES_H); 1343 } 1344 } 1345 1346 1347 1348 1349 static if(!is(typeof(__S16_TYPE))) { 1350 private enum enumMixinStr___S16_TYPE = `enum __S16_TYPE = short int;`; 1351 static if(is(typeof({ mixin(enumMixinStr___S16_TYPE); }))) { 1352 mixin(enumMixinStr___S16_TYPE); 1353 } 1354 } 1355 1356 1357 1358 1359 static if(!is(typeof(__U16_TYPE))) { 1360 private enum enumMixinStr___U16_TYPE = `enum __U16_TYPE = unsigned short int;`; 1361 static if(is(typeof({ mixin(enumMixinStr___U16_TYPE); }))) { 1362 mixin(enumMixinStr___U16_TYPE); 1363 } 1364 } 1365 1366 1367 1368 1369 static if(!is(typeof(__S32_TYPE))) { 1370 private enum enumMixinStr___S32_TYPE = `enum __S32_TYPE = int;`; 1371 static if(is(typeof({ mixin(enumMixinStr___S32_TYPE); }))) { 1372 mixin(enumMixinStr___S32_TYPE); 1373 } 1374 } 1375 1376 1377 1378 1379 static if(!is(typeof(__U32_TYPE))) { 1380 private enum enumMixinStr___U32_TYPE = `enum __U32_TYPE = unsigned int;`; 1381 static if(is(typeof({ mixin(enumMixinStr___U32_TYPE); }))) { 1382 mixin(enumMixinStr___U32_TYPE); 1383 } 1384 } 1385 1386 1387 1388 1389 static if(!is(typeof(__SLONGWORD_TYPE))) { 1390 private enum enumMixinStr___SLONGWORD_TYPE = `enum __SLONGWORD_TYPE = long int;`; 1391 static if(is(typeof({ mixin(enumMixinStr___SLONGWORD_TYPE); }))) { 1392 mixin(enumMixinStr___SLONGWORD_TYPE); 1393 } 1394 } 1395 1396 1397 1398 1399 static if(!is(typeof(__ULONGWORD_TYPE))) { 1400 private enum enumMixinStr___ULONGWORD_TYPE = `enum __ULONGWORD_TYPE = unsigned long int;`; 1401 static if(is(typeof({ mixin(enumMixinStr___ULONGWORD_TYPE); }))) { 1402 mixin(enumMixinStr___ULONGWORD_TYPE); 1403 } 1404 } 1405 1406 1407 1408 1409 static if(!is(typeof(__SQUAD_TYPE))) { 1410 private enum enumMixinStr___SQUAD_TYPE = `enum __SQUAD_TYPE = long int;`; 1411 static if(is(typeof({ mixin(enumMixinStr___SQUAD_TYPE); }))) { 1412 mixin(enumMixinStr___SQUAD_TYPE); 1413 } 1414 } 1415 1416 1417 1418 1419 static if(!is(typeof(__UQUAD_TYPE))) { 1420 private enum enumMixinStr___UQUAD_TYPE = `enum __UQUAD_TYPE = unsigned long int;`; 1421 static if(is(typeof({ mixin(enumMixinStr___UQUAD_TYPE); }))) { 1422 mixin(enumMixinStr___UQUAD_TYPE); 1423 } 1424 } 1425 1426 1427 1428 1429 static if(!is(typeof(__SWORD_TYPE))) { 1430 private enum enumMixinStr___SWORD_TYPE = `enum __SWORD_TYPE = long int;`; 1431 static if(is(typeof({ mixin(enumMixinStr___SWORD_TYPE); }))) { 1432 mixin(enumMixinStr___SWORD_TYPE); 1433 } 1434 } 1435 1436 1437 1438 1439 static if(!is(typeof(__UWORD_TYPE))) { 1440 private enum enumMixinStr___UWORD_TYPE = `enum __UWORD_TYPE = unsigned long int;`; 1441 static if(is(typeof({ mixin(enumMixinStr___UWORD_TYPE); }))) { 1442 mixin(enumMixinStr___UWORD_TYPE); 1443 } 1444 } 1445 1446 1447 1448 1449 static if(!is(typeof(__SLONG32_TYPE))) { 1450 private enum enumMixinStr___SLONG32_TYPE = `enum __SLONG32_TYPE = int;`; 1451 static if(is(typeof({ mixin(enumMixinStr___SLONG32_TYPE); }))) { 1452 mixin(enumMixinStr___SLONG32_TYPE); 1453 } 1454 } 1455 1456 1457 1458 1459 static if(!is(typeof(__ULONG32_TYPE))) { 1460 private enum enumMixinStr___ULONG32_TYPE = `enum __ULONG32_TYPE = unsigned int;`; 1461 static if(is(typeof({ mixin(enumMixinStr___ULONG32_TYPE); }))) { 1462 mixin(enumMixinStr___ULONG32_TYPE); 1463 } 1464 } 1465 1466 1467 1468 1469 static if(!is(typeof(__S64_TYPE))) { 1470 private enum enumMixinStr___S64_TYPE = `enum __S64_TYPE = long int;`; 1471 static if(is(typeof({ mixin(enumMixinStr___S64_TYPE); }))) { 1472 mixin(enumMixinStr___S64_TYPE); 1473 } 1474 } 1475 1476 1477 1478 1479 static if(!is(typeof(__U64_TYPE))) { 1480 private enum enumMixinStr___U64_TYPE = `enum __U64_TYPE = unsigned long int;`; 1481 static if(is(typeof({ mixin(enumMixinStr___U64_TYPE); }))) { 1482 mixin(enumMixinStr___U64_TYPE); 1483 } 1484 } 1485 1486 1487 1488 1489 static if(!is(typeof(__STD_TYPE))) { 1490 private enum enumMixinStr___STD_TYPE = `enum __STD_TYPE = typedef;`; 1491 static if(is(typeof({ mixin(enumMixinStr___STD_TYPE); }))) { 1492 mixin(enumMixinStr___STD_TYPE); 1493 } 1494 } 1495 1496 1497 1498 1499 static if(!is(typeof(_BITS_TYPESIZES_H))) { 1500 private enum enumMixinStr__BITS_TYPESIZES_H = `enum _BITS_TYPESIZES_H = 1;`; 1501 static if(is(typeof({ mixin(enumMixinStr__BITS_TYPESIZES_H); }))) { 1502 mixin(enumMixinStr__BITS_TYPESIZES_H); 1503 } 1504 } 1505 1506 1507 1508 1509 static if(!is(typeof(__SYSCALL_SLONG_TYPE))) { 1510 private enum enumMixinStr___SYSCALL_SLONG_TYPE = `enum __SYSCALL_SLONG_TYPE = long int;`; 1511 static if(is(typeof({ mixin(enumMixinStr___SYSCALL_SLONG_TYPE); }))) { 1512 mixin(enumMixinStr___SYSCALL_SLONG_TYPE); 1513 } 1514 } 1515 1516 1517 1518 1519 static if(!is(typeof(__SYSCALL_ULONG_TYPE))) { 1520 private enum enumMixinStr___SYSCALL_ULONG_TYPE = `enum __SYSCALL_ULONG_TYPE = unsigned long int;`; 1521 static if(is(typeof({ mixin(enumMixinStr___SYSCALL_ULONG_TYPE); }))) { 1522 mixin(enumMixinStr___SYSCALL_ULONG_TYPE); 1523 } 1524 } 1525 1526 1527 1528 1529 static if(!is(typeof(__DEV_T_TYPE))) { 1530 private enum enumMixinStr___DEV_T_TYPE = `enum __DEV_T_TYPE = unsigned long int;`; 1531 static if(is(typeof({ mixin(enumMixinStr___DEV_T_TYPE); }))) { 1532 mixin(enumMixinStr___DEV_T_TYPE); 1533 } 1534 } 1535 1536 1537 1538 1539 static if(!is(typeof(__UID_T_TYPE))) { 1540 private enum enumMixinStr___UID_T_TYPE = `enum __UID_T_TYPE = unsigned int;`; 1541 static if(is(typeof({ mixin(enumMixinStr___UID_T_TYPE); }))) { 1542 mixin(enumMixinStr___UID_T_TYPE); 1543 } 1544 } 1545 1546 1547 1548 1549 static if(!is(typeof(__GID_T_TYPE))) { 1550 private enum enumMixinStr___GID_T_TYPE = `enum __GID_T_TYPE = unsigned int;`; 1551 static if(is(typeof({ mixin(enumMixinStr___GID_T_TYPE); }))) { 1552 mixin(enumMixinStr___GID_T_TYPE); 1553 } 1554 } 1555 1556 1557 1558 1559 static if(!is(typeof(__INO_T_TYPE))) { 1560 private enum enumMixinStr___INO_T_TYPE = `enum __INO_T_TYPE = unsigned long int;`; 1561 static if(is(typeof({ mixin(enumMixinStr___INO_T_TYPE); }))) { 1562 mixin(enumMixinStr___INO_T_TYPE); 1563 } 1564 } 1565 1566 1567 1568 1569 static if(!is(typeof(__INO64_T_TYPE))) { 1570 private enum enumMixinStr___INO64_T_TYPE = `enum __INO64_T_TYPE = unsigned long int;`; 1571 static if(is(typeof({ mixin(enumMixinStr___INO64_T_TYPE); }))) { 1572 mixin(enumMixinStr___INO64_T_TYPE); 1573 } 1574 } 1575 1576 1577 1578 1579 static if(!is(typeof(__MODE_T_TYPE))) { 1580 private enum enumMixinStr___MODE_T_TYPE = `enum __MODE_T_TYPE = unsigned int;`; 1581 static if(is(typeof({ mixin(enumMixinStr___MODE_T_TYPE); }))) { 1582 mixin(enumMixinStr___MODE_T_TYPE); 1583 } 1584 } 1585 1586 1587 1588 1589 static if(!is(typeof(__NLINK_T_TYPE))) { 1590 private enum enumMixinStr___NLINK_T_TYPE = `enum __NLINK_T_TYPE = unsigned long int;`; 1591 static if(is(typeof({ mixin(enumMixinStr___NLINK_T_TYPE); }))) { 1592 mixin(enumMixinStr___NLINK_T_TYPE); 1593 } 1594 } 1595 1596 1597 1598 1599 static if(!is(typeof(__FSWORD_T_TYPE))) { 1600 private enum enumMixinStr___FSWORD_T_TYPE = `enum __FSWORD_T_TYPE = long int;`; 1601 static if(is(typeof({ mixin(enumMixinStr___FSWORD_T_TYPE); }))) { 1602 mixin(enumMixinStr___FSWORD_T_TYPE); 1603 } 1604 } 1605 1606 1607 1608 1609 static if(!is(typeof(__OFF_T_TYPE))) { 1610 private enum enumMixinStr___OFF_T_TYPE = `enum __OFF_T_TYPE = long int;`; 1611 static if(is(typeof({ mixin(enumMixinStr___OFF_T_TYPE); }))) { 1612 mixin(enumMixinStr___OFF_T_TYPE); 1613 } 1614 } 1615 1616 1617 1618 1619 static if(!is(typeof(__OFF64_T_TYPE))) { 1620 private enum enumMixinStr___OFF64_T_TYPE = `enum __OFF64_T_TYPE = long int;`; 1621 static if(is(typeof({ mixin(enumMixinStr___OFF64_T_TYPE); }))) { 1622 mixin(enumMixinStr___OFF64_T_TYPE); 1623 } 1624 } 1625 1626 1627 1628 1629 static if(!is(typeof(__PID_T_TYPE))) { 1630 private enum enumMixinStr___PID_T_TYPE = `enum __PID_T_TYPE = int;`; 1631 static if(is(typeof({ mixin(enumMixinStr___PID_T_TYPE); }))) { 1632 mixin(enumMixinStr___PID_T_TYPE); 1633 } 1634 } 1635 1636 1637 1638 1639 static if(!is(typeof(__RLIM_T_TYPE))) { 1640 private enum enumMixinStr___RLIM_T_TYPE = `enum __RLIM_T_TYPE = unsigned long int;`; 1641 static if(is(typeof({ mixin(enumMixinStr___RLIM_T_TYPE); }))) { 1642 mixin(enumMixinStr___RLIM_T_TYPE); 1643 } 1644 } 1645 1646 1647 1648 1649 static if(!is(typeof(__RLIM64_T_TYPE))) { 1650 private enum enumMixinStr___RLIM64_T_TYPE = `enum __RLIM64_T_TYPE = unsigned long int;`; 1651 static if(is(typeof({ mixin(enumMixinStr___RLIM64_T_TYPE); }))) { 1652 mixin(enumMixinStr___RLIM64_T_TYPE); 1653 } 1654 } 1655 1656 1657 1658 1659 static if(!is(typeof(__BLKCNT_T_TYPE))) { 1660 private enum enumMixinStr___BLKCNT_T_TYPE = `enum __BLKCNT_T_TYPE = long int;`; 1661 static if(is(typeof({ mixin(enumMixinStr___BLKCNT_T_TYPE); }))) { 1662 mixin(enumMixinStr___BLKCNT_T_TYPE); 1663 } 1664 } 1665 1666 1667 1668 1669 static if(!is(typeof(__BLKCNT64_T_TYPE))) { 1670 private enum enumMixinStr___BLKCNT64_T_TYPE = `enum __BLKCNT64_T_TYPE = long int;`; 1671 static if(is(typeof({ mixin(enumMixinStr___BLKCNT64_T_TYPE); }))) { 1672 mixin(enumMixinStr___BLKCNT64_T_TYPE); 1673 } 1674 } 1675 1676 1677 1678 1679 static if(!is(typeof(__FSBLKCNT_T_TYPE))) { 1680 private enum enumMixinStr___FSBLKCNT_T_TYPE = `enum __FSBLKCNT_T_TYPE = unsigned long int;`; 1681 static if(is(typeof({ mixin(enumMixinStr___FSBLKCNT_T_TYPE); }))) { 1682 mixin(enumMixinStr___FSBLKCNT_T_TYPE); 1683 } 1684 } 1685 1686 1687 1688 1689 static if(!is(typeof(__FSBLKCNT64_T_TYPE))) { 1690 private enum enumMixinStr___FSBLKCNT64_T_TYPE = `enum __FSBLKCNT64_T_TYPE = unsigned long int;`; 1691 static if(is(typeof({ mixin(enumMixinStr___FSBLKCNT64_T_TYPE); }))) { 1692 mixin(enumMixinStr___FSBLKCNT64_T_TYPE); 1693 } 1694 } 1695 1696 1697 1698 1699 static if(!is(typeof(__FSFILCNT_T_TYPE))) { 1700 private enum enumMixinStr___FSFILCNT_T_TYPE = `enum __FSFILCNT_T_TYPE = unsigned long int;`; 1701 static if(is(typeof({ mixin(enumMixinStr___FSFILCNT_T_TYPE); }))) { 1702 mixin(enumMixinStr___FSFILCNT_T_TYPE); 1703 } 1704 } 1705 1706 1707 1708 1709 static if(!is(typeof(__FSFILCNT64_T_TYPE))) { 1710 private enum enumMixinStr___FSFILCNT64_T_TYPE = `enum __FSFILCNT64_T_TYPE = unsigned long int;`; 1711 static if(is(typeof({ mixin(enumMixinStr___FSFILCNT64_T_TYPE); }))) { 1712 mixin(enumMixinStr___FSFILCNT64_T_TYPE); 1713 } 1714 } 1715 1716 1717 1718 1719 static if(!is(typeof(__ID_T_TYPE))) { 1720 private enum enumMixinStr___ID_T_TYPE = `enum __ID_T_TYPE = unsigned int;`; 1721 static if(is(typeof({ mixin(enumMixinStr___ID_T_TYPE); }))) { 1722 mixin(enumMixinStr___ID_T_TYPE); 1723 } 1724 } 1725 1726 1727 1728 1729 static if(!is(typeof(__CLOCK_T_TYPE))) { 1730 private enum enumMixinStr___CLOCK_T_TYPE = `enum __CLOCK_T_TYPE = long int;`; 1731 static if(is(typeof({ mixin(enumMixinStr___CLOCK_T_TYPE); }))) { 1732 mixin(enumMixinStr___CLOCK_T_TYPE); 1733 } 1734 } 1735 1736 1737 1738 1739 static if(!is(typeof(__TIME_T_TYPE))) { 1740 private enum enumMixinStr___TIME_T_TYPE = `enum __TIME_T_TYPE = long int;`; 1741 static if(is(typeof({ mixin(enumMixinStr___TIME_T_TYPE); }))) { 1742 mixin(enumMixinStr___TIME_T_TYPE); 1743 } 1744 } 1745 1746 1747 1748 1749 static if(!is(typeof(__USECONDS_T_TYPE))) { 1750 private enum enumMixinStr___USECONDS_T_TYPE = `enum __USECONDS_T_TYPE = unsigned int;`; 1751 static if(is(typeof({ mixin(enumMixinStr___USECONDS_T_TYPE); }))) { 1752 mixin(enumMixinStr___USECONDS_T_TYPE); 1753 } 1754 } 1755 1756 1757 1758 1759 static if(!is(typeof(__SUSECONDS_T_TYPE))) { 1760 private enum enumMixinStr___SUSECONDS_T_TYPE = `enum __SUSECONDS_T_TYPE = long int;`; 1761 static if(is(typeof({ mixin(enumMixinStr___SUSECONDS_T_TYPE); }))) { 1762 mixin(enumMixinStr___SUSECONDS_T_TYPE); 1763 } 1764 } 1765 1766 1767 1768 1769 static if(!is(typeof(__DADDR_T_TYPE))) { 1770 private enum enumMixinStr___DADDR_T_TYPE = `enum __DADDR_T_TYPE = int;`; 1771 static if(is(typeof({ mixin(enumMixinStr___DADDR_T_TYPE); }))) { 1772 mixin(enumMixinStr___DADDR_T_TYPE); 1773 } 1774 } 1775 1776 1777 1778 1779 static if(!is(typeof(__KEY_T_TYPE))) { 1780 private enum enumMixinStr___KEY_T_TYPE = `enum __KEY_T_TYPE = int;`; 1781 static if(is(typeof({ mixin(enumMixinStr___KEY_T_TYPE); }))) { 1782 mixin(enumMixinStr___KEY_T_TYPE); 1783 } 1784 } 1785 1786 1787 1788 1789 static if(!is(typeof(__CLOCKID_T_TYPE))) { 1790 private enum enumMixinStr___CLOCKID_T_TYPE = `enum __CLOCKID_T_TYPE = int;`; 1791 static if(is(typeof({ mixin(enumMixinStr___CLOCKID_T_TYPE); }))) { 1792 mixin(enumMixinStr___CLOCKID_T_TYPE); 1793 } 1794 } 1795 1796 1797 1798 1799 static if(!is(typeof(__TIMER_T_TYPE))) { 1800 private enum enumMixinStr___TIMER_T_TYPE = `enum __TIMER_T_TYPE = void *;`; 1801 static if(is(typeof({ mixin(enumMixinStr___TIMER_T_TYPE); }))) { 1802 mixin(enumMixinStr___TIMER_T_TYPE); 1803 } 1804 } 1805 1806 1807 1808 1809 static if(!is(typeof(__BLKSIZE_T_TYPE))) { 1810 private enum enumMixinStr___BLKSIZE_T_TYPE = `enum __BLKSIZE_T_TYPE = long int;`; 1811 static if(is(typeof({ mixin(enumMixinStr___BLKSIZE_T_TYPE); }))) { 1812 mixin(enumMixinStr___BLKSIZE_T_TYPE); 1813 } 1814 } 1815 1816 1817 1818 1819 static if(!is(typeof(__FSID_T_TYPE))) { 1820 private enum enumMixinStr___FSID_T_TYPE = `enum __FSID_T_TYPE = { int __val [ 2 ] ; };`; 1821 static if(is(typeof({ mixin(enumMixinStr___FSID_T_TYPE); }))) { 1822 mixin(enumMixinStr___FSID_T_TYPE); 1823 } 1824 } 1825 1826 1827 1828 1829 static if(!is(typeof(__SSIZE_T_TYPE))) { 1830 private enum enumMixinStr___SSIZE_T_TYPE = `enum __SSIZE_T_TYPE = long int;`; 1831 static if(is(typeof({ mixin(enumMixinStr___SSIZE_T_TYPE); }))) { 1832 mixin(enumMixinStr___SSIZE_T_TYPE); 1833 } 1834 } 1835 1836 1837 1838 1839 static if(!is(typeof(__CPU_MASK_TYPE))) { 1840 private enum enumMixinStr___CPU_MASK_TYPE = `enum __CPU_MASK_TYPE = unsigned long int;`; 1841 static if(is(typeof({ mixin(enumMixinStr___CPU_MASK_TYPE); }))) { 1842 mixin(enumMixinStr___CPU_MASK_TYPE); 1843 } 1844 } 1845 1846 1847 1848 1849 static if(!is(typeof(__OFF_T_MATCHES_OFF64_T))) { 1850 private enum enumMixinStr___OFF_T_MATCHES_OFF64_T = `enum __OFF_T_MATCHES_OFF64_T = 1;`; 1851 static if(is(typeof({ mixin(enumMixinStr___OFF_T_MATCHES_OFF64_T); }))) { 1852 mixin(enumMixinStr___OFF_T_MATCHES_OFF64_T); 1853 } 1854 } 1855 1856 1857 1858 1859 static if(!is(typeof(__INO_T_MATCHES_INO64_T))) { 1860 private enum enumMixinStr___INO_T_MATCHES_INO64_T = `enum __INO_T_MATCHES_INO64_T = 1;`; 1861 static if(is(typeof({ mixin(enumMixinStr___INO_T_MATCHES_INO64_T); }))) { 1862 mixin(enumMixinStr___INO_T_MATCHES_INO64_T); 1863 } 1864 } 1865 1866 1867 1868 1869 static if(!is(typeof(__RLIM_T_MATCHES_RLIM64_T))) { 1870 private enum enumMixinStr___RLIM_T_MATCHES_RLIM64_T = `enum __RLIM_T_MATCHES_RLIM64_T = 1;`; 1871 static if(is(typeof({ mixin(enumMixinStr___RLIM_T_MATCHES_RLIM64_T); }))) { 1872 mixin(enumMixinStr___RLIM_T_MATCHES_RLIM64_T); 1873 } 1874 } 1875 1876 1877 1878 1879 static if(!is(typeof(__FD_SETSIZE))) { 1880 private enum enumMixinStr___FD_SETSIZE = `enum __FD_SETSIZE = 1024;`; 1881 static if(is(typeof({ mixin(enumMixinStr___FD_SETSIZE); }))) { 1882 mixin(enumMixinStr___FD_SETSIZE); 1883 } 1884 } 1885 1886 1887 1888 1889 static if(!is(typeof(_BITS_WCHAR_H))) { 1890 private enum enumMixinStr__BITS_WCHAR_H = `enum _BITS_WCHAR_H = 1;`; 1891 static if(is(typeof({ mixin(enumMixinStr__BITS_WCHAR_H); }))) { 1892 mixin(enumMixinStr__BITS_WCHAR_H); 1893 } 1894 } 1895 1896 1897 1898 1899 static if(!is(typeof(__WCHAR_MAX))) { 1900 private enum enumMixinStr___WCHAR_MAX = `enum __WCHAR_MAX = 0x7fffffff;`; 1901 static if(is(typeof({ mixin(enumMixinStr___WCHAR_MAX); }))) { 1902 mixin(enumMixinStr___WCHAR_MAX); 1903 } 1904 } 1905 1906 1907 1908 1909 static if(!is(typeof(__WCHAR_MIN))) { 1910 private enum enumMixinStr___WCHAR_MIN = `enum __WCHAR_MIN = ( - 0x7fffffff - 1 );`; 1911 static if(is(typeof({ mixin(enumMixinStr___WCHAR_MIN); }))) { 1912 mixin(enumMixinStr___WCHAR_MIN); 1913 } 1914 } 1915 1916 1917 1918 1919 static if(!is(typeof(__WORDSIZE))) { 1920 private enum enumMixinStr___WORDSIZE = `enum __WORDSIZE = 64;`; 1921 static if(is(typeof({ mixin(enumMixinStr___WORDSIZE); }))) { 1922 mixin(enumMixinStr___WORDSIZE); 1923 } 1924 } 1925 1926 1927 1928 1929 static if(!is(typeof(__WORDSIZE_TIME64_COMPAT32))) { 1930 private enum enumMixinStr___WORDSIZE_TIME64_COMPAT32 = `enum __WORDSIZE_TIME64_COMPAT32 = 1;`; 1931 static if(is(typeof({ mixin(enumMixinStr___WORDSIZE_TIME64_COMPAT32); }))) { 1932 mixin(enumMixinStr___WORDSIZE_TIME64_COMPAT32); 1933 } 1934 } 1935 1936 1937 1938 1939 static if(!is(typeof(__SYSCALL_WORDSIZE))) { 1940 private enum enumMixinStr___SYSCALL_WORDSIZE = `enum __SYSCALL_WORDSIZE = 64;`; 1941 static if(is(typeof({ mixin(enumMixinStr___SYSCALL_WORDSIZE); }))) { 1942 mixin(enumMixinStr___SYSCALL_WORDSIZE); 1943 } 1944 } 1945 static if(!is(typeof(_SYS_CDEFS_H))) { 1946 private enum enumMixinStr__SYS_CDEFS_H = `enum _SYS_CDEFS_H = 1;`; 1947 static if(is(typeof({ mixin(enumMixinStr__SYS_CDEFS_H); }))) { 1948 mixin(enumMixinStr__SYS_CDEFS_H); 1949 } 1950 } 1951 static if(!is(typeof(__THROW))) { 1952 private enum enumMixinStr___THROW = `enum __THROW = __attribute__ ( ( __nothrow__ ) );`; 1953 static if(is(typeof({ mixin(enumMixinStr___THROW); }))) { 1954 mixin(enumMixinStr___THROW); 1955 } 1956 } 1957 1958 1959 1960 1961 static if(!is(typeof(__THROWNL))) { 1962 private enum enumMixinStr___THROWNL = `enum __THROWNL = __attribute__ ( ( __nothrow__ ) );`; 1963 static if(is(typeof({ mixin(enumMixinStr___THROWNL); }))) { 1964 mixin(enumMixinStr___THROWNL); 1965 } 1966 } 1967 static if(!is(typeof(__ptr_t))) { 1968 private enum enumMixinStr___ptr_t = `enum __ptr_t = void *;`; 1969 static if(is(typeof({ mixin(enumMixinStr___ptr_t); }))) { 1970 mixin(enumMixinStr___ptr_t); 1971 } 1972 } 1973 static if(!is(typeof(__flexarr))) { 1974 private enum enumMixinStr___flexarr = `enum __flexarr = [ ];`; 1975 static if(is(typeof({ mixin(enumMixinStr___flexarr); }))) { 1976 mixin(enumMixinStr___flexarr); 1977 } 1978 } 1979 1980 1981 1982 1983 static if(!is(typeof(__glibc_c99_flexarr_available))) { 1984 private enum enumMixinStr___glibc_c99_flexarr_available = `enum __glibc_c99_flexarr_available = 1;`; 1985 static if(is(typeof({ mixin(enumMixinStr___glibc_c99_flexarr_available); }))) { 1986 mixin(enumMixinStr___glibc_c99_flexarr_available); 1987 } 1988 } 1989 static if(!is(typeof(__attribute_malloc__))) { 1990 private enum enumMixinStr___attribute_malloc__ = `enum __attribute_malloc__ = __attribute__ ( ( __malloc__ ) );`; 1991 static if(is(typeof({ mixin(enumMixinStr___attribute_malloc__); }))) { 1992 mixin(enumMixinStr___attribute_malloc__); 1993 } 1994 } 1995 1996 1997 1998 1999 2000 2001 static if(!is(typeof(__attribute_pure__))) { 2002 private enum enumMixinStr___attribute_pure__ = `enum __attribute_pure__ = __attribute__ ( ( __pure__ ) );`; 2003 static if(is(typeof({ mixin(enumMixinStr___attribute_pure__); }))) { 2004 mixin(enumMixinStr___attribute_pure__); 2005 } 2006 } 2007 2008 2009 2010 2011 static if(!is(typeof(__attribute_const__))) { 2012 private enum enumMixinStr___attribute_const__ = `enum __attribute_const__ = __attribute__ ( cast( __const__ ) );`; 2013 static if(is(typeof({ mixin(enumMixinStr___attribute_const__); }))) { 2014 mixin(enumMixinStr___attribute_const__); 2015 } 2016 } 2017 2018 2019 2020 2021 static if(!is(typeof(__attribute_used__))) { 2022 private enum enumMixinStr___attribute_used__ = `enum __attribute_used__ = __attribute__ ( ( __used__ ) );`; 2023 static if(is(typeof({ mixin(enumMixinStr___attribute_used__); }))) { 2024 mixin(enumMixinStr___attribute_used__); 2025 } 2026 } 2027 2028 2029 2030 2031 static if(!is(typeof(__attribute_noinline__))) { 2032 private enum enumMixinStr___attribute_noinline__ = `enum __attribute_noinline__ = __attribute__ ( ( __noinline__ ) );`; 2033 static if(is(typeof({ mixin(enumMixinStr___attribute_noinline__); }))) { 2034 mixin(enumMixinStr___attribute_noinline__); 2035 } 2036 } 2037 2038 2039 2040 2041 static if(!is(typeof(__attribute_deprecated__))) { 2042 private enum enumMixinStr___attribute_deprecated__ = `enum __attribute_deprecated__ = __attribute__ ( ( __deprecated__ ) );`; 2043 static if(is(typeof({ mixin(enumMixinStr___attribute_deprecated__); }))) { 2044 mixin(enumMixinStr___attribute_deprecated__); 2045 } 2046 } 2047 static if(!is(typeof(__attribute_warn_unused_result__))) { 2048 private enum enumMixinStr___attribute_warn_unused_result__ = `enum __attribute_warn_unused_result__ = __attribute__ ( ( __warn_unused_result__ ) );`; 2049 static if(is(typeof({ mixin(enumMixinStr___attribute_warn_unused_result__); }))) { 2050 mixin(enumMixinStr___attribute_warn_unused_result__); 2051 } 2052 } 2053 2054 2055 2056 2057 2058 2059 static if(!is(typeof(__always_inline))) { 2060 private enum enumMixinStr___always_inline = `enum __always_inline = __inline __attribute__ ( ( __always_inline__ ) );`; 2061 static if(is(typeof({ mixin(enumMixinStr___always_inline); }))) { 2062 mixin(enumMixinStr___always_inline); 2063 } 2064 } 2065 2066 2067 2068 2069 2070 2071 static if(!is(typeof(__extern_inline))) { 2072 private enum enumMixinStr___extern_inline = `enum __extern_inline = extern __inline __attribute__ ( ( __gnu_inline__ ) );`; 2073 static if(is(typeof({ mixin(enumMixinStr___extern_inline); }))) { 2074 mixin(enumMixinStr___extern_inline); 2075 } 2076 } 2077 2078 2079 2080 2081 static if(!is(typeof(__extern_always_inline))) { 2082 private enum enumMixinStr___extern_always_inline = `enum __extern_always_inline = extern __inline __attribute__ ( ( __always_inline__ ) ) __attribute__ ( ( __gnu_inline__ ) );`; 2083 static if(is(typeof({ mixin(enumMixinStr___extern_always_inline); }))) { 2084 mixin(enumMixinStr___extern_always_inline); 2085 } 2086 } 2087 2088 2089 2090 2091 static if(!is(typeof(__fortify_function))) { 2092 private enum enumMixinStr___fortify_function = `enum __fortify_function = extern __inline __attribute__ ( ( __always_inline__ ) ) __attribute__ ( ( __gnu_inline__ ) ) ;`; 2093 static if(is(typeof({ mixin(enumMixinStr___fortify_function); }))) { 2094 mixin(enumMixinStr___fortify_function); 2095 } 2096 } 2097 2098 2099 2100 2101 static if(!is(typeof(__restrict_arr))) { 2102 private enum enumMixinStr___restrict_arr = `enum __restrict_arr = __restrict;`; 2103 static if(is(typeof({ mixin(enumMixinStr___restrict_arr); }))) { 2104 mixin(enumMixinStr___restrict_arr); 2105 } 2106 } 2107 static if(!is(typeof(__HAVE_GENERIC_SELECTION))) { 2108 private enum enumMixinStr___HAVE_GENERIC_SELECTION = `enum __HAVE_GENERIC_SELECTION = 1;`; 2109 static if(is(typeof({ mixin(enumMixinStr___HAVE_GENERIC_SELECTION); }))) { 2110 mixin(enumMixinStr___HAVE_GENERIC_SELECTION); 2111 } 2112 } 2113 }