1 module libzipd.libziph; 2 3 4 /* 5 6 Generated with dpp (https://github.com/atilaneves/dpp) 7 beautified with dfmt 8 9 generated on Linux Mint 20 on January 23 2021 using: 10 // Package: libzip-dev 11 // Architecture: amd64 12 // Version: 1.5.1-0ubuntu1 13 // Multi-Arch: same 14 // Priority: optional 15 // Section: universe/libdevel 16 // Source: libzip 17 // Origin: Ubuntu 18 // Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com> 19 // Original-Maintainer: Stefan Schörghofer <amd1212@4md.gr> 20 21 */ 22 import core.stdc.config; 23 import core.stdc.stdarg : va_list; 24 static import core.simd; 25 static import std.conv; 26 27 struct Int128 28 { 29 long lower; 30 long upper; 31 } 32 33 struct UInt128 34 { 35 ulong lower; 36 ulong upper; 37 } 38 39 struct __locale_data 40 { 41 int dummy; 42 } 43 44 alias _Bool = bool; 45 struct dpp 46 { 47 static struct Opaque(int N) 48 { 49 void[N] bytes; 50 } 51 52 static bool isEmpty(T)() 53 { 54 return T.tupleof.length == 0; 55 } 56 57 static struct Move(T) 58 { 59 T* ptr; 60 } 61 62 static auto move(T)(ref T value) 63 { 64 return Move!T(&value); 65 } 66 67 mixin template EnumD(string name, T, string prefix) if (is(T == enum)) 68 { 69 private static string _memberMixinStr(string member) 70 { 71 import std.conv : text; 72 import std.array : replace; 73 74 return text(` `, member.replace(prefix, ""), ` = `, T.stringof, `.`, member, `,`); 75 } 76 77 private static string _enumMixinStr() 78 { 79 import std.array : join; 80 81 string[] ret; 82 ret ~= "enum " ~ name ~ "{"; 83 static foreach (member; __traits(allMembers, T)) 84 { 85 ret ~= _memberMixinStr(member); 86 } 87 ret ~= "}"; 88 return ret.join("\n"); 89 } 90 91 mixin(_enumMixinStr()); 92 } 93 } 94 95 extern (C) 96 { 97 alias size_t = c_ulong; 98 alias zip_uint64_t = c_ulong; 99 alias zip_int64_t = c_long; 100 alias zip_uint32_t = uint; 101 alias zip_int32_t = int; 102 alias zip_uint16_t = ushort; 103 alias zip_int16_t = short; 104 alias zip_uint8_t = ubyte; 105 alias zip_int8_t = byte; 106 int zip_unchange_archive(zip*) @nogc nothrow; 107 int zip_unchange_all(zip*) @nogc nothrow; 108 int zip_unchange(zip*, c_ulong) @nogc nothrow; 109 const(char)* zip_strerror(zip*) @nogc nothrow; 110 void zip_stat_init(zip_stat*) @nogc nothrow; 111 int zip_stat_index(zip*, c_ulong, uint, zip_stat*) @nogc nothrow; 112 pragma(mangle, "zip_stat") int zip_stat_(zip*, const(char)*, uint, zip_stat*) @nogc nothrow; 113 zip_source* zip_source_zip(zip*, zip*, c_ulong, uint, c_ulong, c_long) @nogc nothrow; 114 c_long zip_source_write(zip_source*, const(void)*, c_ulong) @nogc nothrow; 115 c_long zip_source_tell_write(zip_source*) @nogc nothrow; 116 c_long zip_source_tell(zip_source*) @nogc nothrow; 117 int zip_source_stat(zip_source*, zip_stat*) @nogc nothrow; 118 int zip_source_seek_write(zip_source*, c_long, int) @nogc nothrow; 119 c_long zip_source_seek_compute_offset(c_ulong, c_ulong, void*, c_ulong, zip_error*) @nogc nothrow; 120 int zip_source_seek(zip_source*, c_long, int) @nogc nothrow; 121 void zip_source_rollback_write(zip_source*) @nogc nothrow; 122 c_long zip_source_read(zip_source*, void*, c_ulong) @nogc nothrow; 123 int zip_source_open(zip_source*) @nogc nothrow; 124 c_long zip_source_make_command_bitmap(zip_source_cmd, ...) @nogc nothrow; 125 void zip_source_keep(zip_source*) @nogc nothrow; 126 int zip_source_is_deleted(zip_source*) @nogc nothrow; 127 zip_source* zip_source_function_create(c_long function(void*, void*, 128 c_ulong, zip_source_cmd), void*, zip_error*) @nogc nothrow; 129 zip_source* zip_source_function(zip*, c_long function(void*, void*, 130 c_ulong, zip_source_cmd), void*) @nogc nothrow; 131 void zip_source_free(zip_source*) @nogc nothrow; 132 zip_source* zip_source_filep_create(_IO_FILE*, c_ulong, c_long, zip_error*) @nogc nothrow; 133 zip_source* zip_source_filep(zip*, _IO_FILE*, c_ulong, c_long) @nogc nothrow; 134 zip_source* zip_source_file_create(const(char)*, c_ulong, c_long, zip_error*) @nogc nothrow; 135 zip_source* zip_source_file(zip*, const(char)*, c_ulong, c_long) @nogc nothrow; 136 zip_error* zip_source_error(zip_source*) @nogc nothrow; 137 int zip_source_commit_write(zip_source*) @nogc nothrow; 138 int zip_source_close(zip_source*) @nogc nothrow; 139 zip_source* zip_source_buffer_fragment_create(const(zip_buffer_fragment)*, 140 c_ulong, int, zip_error*) @nogc nothrow; 141 zip_source* zip_source_buffer_fragment(zip*, const(zip_buffer_fragment)*, c_ulong, int) @nogc nothrow; 142 zip_source* zip_source_buffer_create(const(void)*, c_ulong, int, zip_error*) @nogc nothrow; 143 zip_source* zip_source_buffer(zip*, const(void)*, c_ulong, int) @nogc nothrow; 144 int zip_source_begin_write_cloning(zip_source*, c_ulong) @nogc nothrow; 145 int zip_source_begin_write(zip_source*) @nogc nothrow; 146 int zip_set_file_compression(zip*, c_ulong, int, uint) @nogc nothrow; 147 int zip_set_default_password(zip*, const(char)*) @nogc nothrow; 148 int zip_set_archive_flag(zip*, uint, int) @nogc nothrow; 149 int zip_set_archive_comment(zip*, const(char)*, ushort) @nogc nothrow; 150 int zip_register_progress_callback_with_state(zip*, double, 151 void function(zip*, double, void*), void function(void*), void*) @nogc nothrow; 152 zip* zip_open_from_source(zip_source*, int, zip_error*) @nogc nothrow; 153 zip* zip_open(const(char)*, int, int*) @nogc nothrow; 154 c_long zip_name_locate(zip*, const(char)*, uint) @nogc nothrow; 155 const(char)* zip_libzip_version() @nogc nothrow; 156 c_long zip_get_num_entries(zip*, uint) @nogc nothrow; 157 const(char)* zip_get_name(zip*, c_ulong, uint) @nogc nothrow; 158 int zip_get_archive_flag(zip*, uint, uint) @nogc nothrow; 159 const(char)* zip_get_archive_comment(zip*, int*, uint) @nogc nothrow; 160 c_long zip_ftell(zip_file*) @nogc nothrow; 161 byte zip_fseek(zip_file*, c_long, int) @nogc nothrow; 162 c_long zip_fread(zip_file*, void*, c_ulong) @nogc nothrow; 163 zip_file* zip_fopen_index_encrypted(zip*, c_ulong, uint, const(char)*) @nogc nothrow; 164 zip_file* zip_fopen_index(zip*, c_ulong, uint) @nogc nothrow; 165 zip_file* zip_fopen_encrypted(zip*, const(char)*, uint, const(char)*) @nogc nothrow; 166 zip_file* zip_fopen(zip*, const(char)*, uint) @nogc nothrow; 167 const(char)* zip_file_strerror(zip_file*) @nogc nothrow; 168 int zip_file_set_mtime(zip*, c_ulong, c_long, uint) @nogc nothrow; 169 int zip_file_set_external_attributes(zip*, c_ulong, uint, ubyte, uint) @nogc nothrow; 170 int zip_file_set_encryption(zip*, c_ulong, ushort, const(char)*) @nogc nothrow; 171 int zip_file_set_comment(zip*, c_ulong, const(char)*, ushort, uint) @nogc nothrow; 172 int zip_file_replace(zip*, c_ulong, zip_source*, uint) @nogc nothrow; 173 int zip_file_rename(zip*, c_ulong, const(char)*, uint) @nogc nothrow; 174 int zip_file_get_external_attributes(zip*, c_ulong, uint, ubyte*, uint*) @nogc nothrow; 175 zip_error* zip_file_get_error(zip_file*) @nogc nothrow; 176 const(char)* zip_file_get_comment(zip*, c_ulong, uint*, uint) @nogc nothrow; 177 const(ubyte)* zip_file_extra_field_get_by_id(zip*, c_ulong, ushort, ushort, ushort*, uint) @nogc nothrow; 178 const(ubyte)* zip_file_extra_field_get(zip*, c_ulong, ushort, ushort*, ushort*, uint) @nogc nothrow; 179 short zip_file_extra_fields_count_by_id(zip*, c_ulong, ushort, uint) @nogc nothrow; 180 short zip_file_extra_fields_count(zip*, c_ulong, uint) @nogc nothrow; 181 int zip_file_extra_field_set(zip*, c_ulong, ushort, ushort, const(ubyte)*, ushort, uint) @nogc nothrow; 182 int zip_file_extra_field_delete_by_id(zip*, c_ulong, ushort, ushort, uint) @nogc nothrow; 183 int zip_file_extra_field_delete(zip*, c_ulong, ushort, uint) @nogc nothrow; 184 void zip_file_error_clear(zip_file*) @nogc nothrow; 185 c_long zip_file_add(zip*, const(char)*, zip_source*, uint) @nogc nothrow; 186 zip* zip_fdopen(int, int, int*) @nogc nothrow; 187 int zip_fclose(zip_file*) @nogc nothrow; 188 c_long zip_error_to_data(const(zip_error)*, void*, c_ulong) @nogc nothrow; 189 int zip_error_system_type(const(zip_error)*) @nogc nothrow; 190 const(char)* zip_error_strerror(zip_error*) @nogc nothrow; 191 void zip_error_set(zip_error*, int, int) @nogc nothrow; 192 void zip_error_init_with_code(zip_error*, int) @nogc nothrow; 193 void zip_error_init(zip_error*) @nogc nothrow; 194 void zip_error_fini(zip_error*) @nogc nothrow; 195 int zip_error_code_system(const(zip_error)*) @nogc nothrow; 196 int zip_error_code_zip(const(zip_error)*) @nogc nothrow; 197 void zip_error_clear(zip*) @nogc nothrow; 198 zip_error* zip_get_error(zip*) @nogc nothrow; 199 void zip_discard(zip*) @nogc nothrow; 200 c_long zip_dir_add(zip*, const(char)*, uint) @nogc nothrow; 201 int zip_delete(zip*, c_ulong) @nogc nothrow; 202 int zip_close(zip*) @nogc nothrow; 203 void zip_file_error_get(zip_file*, int*, int*) @nogc nothrow; 204 int zip_error_to_str(char*, c_ulong, int, int) @nogc nothrow; 205 void zip_error_get(zip*, int*, int*) @nogc nothrow; 206 int zip_error_get_sys_type(int) @nogc nothrow; 207 int zip_set_file_comment(zip*, c_ulong, const(char)*, int) @nogc nothrow; 208 int zip_replace(zip*, c_ulong, zip_source*) @nogc nothrow; 209 int zip_rename(zip*, c_ulong, const(char)*) @nogc nothrow; 210 int zip_get_num_files(zip*) @nogc nothrow; 211 const(char)* zip_get_file_comment(zip*, c_ulong, int*, int) @nogc nothrow; 212 c_long zip_add_dir(zip*, const(char)*) @nogc nothrow; 213 c_long zip_add(zip*, const(char)*, zip_source*) @nogc nothrow; 214 void zip_register_progress_callback(zip*, void function(double)) @nogc nothrow; 215 alias zip_progress_callback_t = void function(double); 216 alias zip_progress_callback = void function(zip*, double, void*); 217 alias zip_source_callback = c_long function(void*, void*, c_ulong, zip_source_cmd); 218 alias zip_flags_t = uint; 219 alias zip_buffer_fragment_t = zip_buffer_fragment; 220 alias zip_stat_t = zip_stat; 221 alias zip_source_t = zip_source; 222 alias zip_file_t = zip_file; 223 alias zip_error_t = zip_error; 224 alias zip_t = zip; 225 struct zip_source; 226 struct zip_file; 227 struct zip; 228 struct zip_buffer_fragment 229 { 230 ubyte* data; 231 c_ulong length; 232 } 233 234 struct zip_stat 235 { 236 c_ulong valid; 237 const(char)* name; 238 c_ulong index; 239 c_ulong size; 240 c_ulong comp_size; 241 c_long mtime; 242 uint crc; 243 ushort comp_method; 244 ushort encryption_method; 245 uint flags; 246 } 247 248 struct zip_error 249 { 250 int zip_err; 251 int sys_err; 252 char* str; 253 } 254 255 alias zip_source_args_seek_t = zip_source_args_seek; 256 struct zip_source_args_seek 257 { 258 c_long offset; 259 int whence; 260 } 261 262 alias zip_source_cmd_t = zip_source_cmd; 263 enum zip_source_cmd 264 { 265 ZIP_SOURCE_OPEN = 0, 266 ZIP_SOURCE_READ = 1, 267 ZIP_SOURCE_CLOSE = 2, 268 ZIP_SOURCE_STAT = 3, 269 ZIP_SOURCE_ERROR = 4, 270 ZIP_SOURCE_FREE = 5, 271 ZIP_SOURCE_SEEK = 6, 272 ZIP_SOURCE_TELL = 7, 273 ZIP_SOURCE_BEGIN_WRITE = 8, 274 ZIP_SOURCE_COMMIT_WRITE = 9, 275 ZIP_SOURCE_ROLLBACK_WRITE = 10, 276 ZIP_SOURCE_WRITE = 11, 277 ZIP_SOURCE_SEEK_WRITE = 12, 278 ZIP_SOURCE_TELL_WRITE = 13, 279 ZIP_SOURCE_SUPPORTS = 14, 280 ZIP_SOURCE_REMOVE = 15, 281 ZIP_SOURCE_GET_COMPRESSION_FLAGS = 16, 282 ZIP_SOURCE_BEGIN_WRITE_CLONING = 17, 283 } 284 285 enum ZIP_SOURCE_OPEN = zip_source_cmd.ZIP_SOURCE_OPEN; 286 enum ZIP_SOURCE_READ = zip_source_cmd.ZIP_SOURCE_READ; 287 enum ZIP_SOURCE_CLOSE = zip_source_cmd.ZIP_SOURCE_CLOSE; 288 enum ZIP_SOURCE_STAT = zip_source_cmd.ZIP_SOURCE_STAT; 289 enum ZIP_SOURCE_ERROR = zip_source_cmd.ZIP_SOURCE_ERROR; 290 enum ZIP_SOURCE_FREE = zip_source_cmd.ZIP_SOURCE_FREE; 291 enum ZIP_SOURCE_SEEK = zip_source_cmd.ZIP_SOURCE_SEEK; 292 enum ZIP_SOURCE_TELL = zip_source_cmd.ZIP_SOURCE_TELL; 293 enum ZIP_SOURCE_BEGIN_WRITE = zip_source_cmd.ZIP_SOURCE_BEGIN_WRITE; 294 enum ZIP_SOURCE_COMMIT_WRITE = zip_source_cmd.ZIP_SOURCE_COMMIT_WRITE; 295 enum ZIP_SOURCE_ROLLBACK_WRITE = zip_source_cmd.ZIP_SOURCE_ROLLBACK_WRITE; 296 enum ZIP_SOURCE_WRITE = zip_source_cmd.ZIP_SOURCE_WRITE; 297 enum ZIP_SOURCE_SEEK_WRITE = zip_source_cmd.ZIP_SOURCE_SEEK_WRITE; 298 enum ZIP_SOURCE_TELL_WRITE = zip_source_cmd.ZIP_SOURCE_TELL_WRITE; 299 enum ZIP_SOURCE_SUPPORTS = zip_source_cmd.ZIP_SOURCE_SUPPORTS; 300 enum ZIP_SOURCE_REMOVE = zip_source_cmd.ZIP_SOURCE_REMOVE; 301 enum ZIP_SOURCE_GET_COMPRESSION_FLAGS = zip_source_cmd.ZIP_SOURCE_GET_COMPRESSION_FLAGS; 302 enum ZIP_SOURCE_BEGIN_WRITE_CLONING = zip_source_cmd.ZIP_SOURCE_BEGIN_WRITE_CLONING; 303 alias fsfilcnt_t = c_ulong; 304 alias fsblkcnt_t = c_ulong; 305 alias blkcnt_t = c_long; 306 alias blksize_t = c_long; 307 alias register_t = c_long; 308 alias u_int64_t = c_ulong; 309 alias u_int32_t = uint; 310 alias u_int16_t = ushort; 311 alias u_int8_t = ubyte; 312 alias key_t = int; 313 alias caddr_t = char*; 314 alias daddr_t = int; 315 alias id_t = uint; 316 alias pid_t = int; 317 alias uid_t = uint; 318 alias nlink_t = c_ulong; 319 alias mode_t = uint; 320 alias gid_t = uint; 321 alias dev_t = c_ulong; 322 alias ino_t = c_ulong; 323 alias loff_t = c_long; 324 alias fsid_t = __fsid_t; 325 alias u_quad_t = c_ulong; 326 alias quad_t = c_long; 327 alias u_long = c_ulong; 328 alias u_int = uint; 329 alias u_short = ushort; 330 alias u_char = ubyte; 331 int pselect(int, fd_set*, fd_set*, fd_set*, const(timespec)*, const(__sigset_t)*) @nogc nothrow; 332 int select(int, fd_set*, fd_set*, fd_set*, timeval*) @nogc nothrow; 333 alias fd_mask = c_long; 334 struct fd_set 335 { 336 c_long[16] __fds_bits; 337 } 338 339 alias __fd_mask = c_long; 340 alias suseconds_t = c_long; 341 alias int_least8_t = byte; 342 alias int_least16_t = short; 343 alias int_least32_t = int; 344 alias int_least64_t = c_long; 345 alias uint_least8_t = ubyte; 346 alias uint_least16_t = ushort; 347 alias uint_least32_t = uint; 348 alias uint_least64_t = c_ulong; 349 alias int_fast8_t = byte; 350 alias int_fast16_t = c_long; 351 alias int_fast32_t = c_long; 352 alias int_fast64_t = c_long; 353 alias uint_fast8_t = ubyte; 354 alias uint_fast16_t = c_ulong; 355 alias uint_fast32_t = c_ulong; 356 alias uint_fast64_t = c_ulong; 357 alias intptr_t = c_long; 358 alias uintptr_t = c_ulong; 359 alias intmax_t = c_long; 360 alias uintmax_t = c_ulong; 361 static c_ulong __uint64_identity(c_ulong) @nogc nothrow; 362 static uint __uint32_identity(uint) @nogc nothrow; 363 static ushort __uint16_identity(ushort) @nogc nothrow; 364 alias timer_t = void*; 365 alias time_t = c_long; 366 struct tm 367 { 368 int tm_sec; 369 int tm_min; 370 int tm_hour; 371 int tm_mday; 372 int tm_mon; 373 int tm_year; 374 int tm_wday; 375 int tm_yday; 376 int tm_isdst; 377 c_long tm_gmtoff; 378 const(char)* tm_zone; 379 } 380 381 struct timeval 382 { 383 c_long tv_sec; 384 c_long tv_usec; 385 } 386 387 struct timespec 388 { 389 c_long tv_sec; 390 c_long tv_nsec; 391 } 392 393 struct itimerspec 394 { 395 timespec it_interval; 396 timespec it_value; 397 } 398 399 alias _IO_lock_t = void; 400 struct _IO_wide_data; 401 struct _IO_codecvt; 402 struct _IO_marker; 403 alias sigset_t = __sigset_t; 404 alias locale_t = __locale_struct*; 405 alias clockid_t = int; 406 alias clock_t = c_long; 407 alias off_t = c_long; 408 alias ssize_t = c_long; 409 struct __sigset_t 410 { 411 c_ulong[16] __val; 412 } 413 414 alias fpos_t = _G_fpos_t; 415 struct __mbstate_t 416 { 417 int __count; 418 static union _Anonymous_0 419 { 420 uint __wch; 421 char[4] __wchb; 422 } 423 424 _Anonymous_0 __value; 425 } 426 427 alias __locale_t = __locale_struct*; 428 struct __locale_struct 429 { 430 __locale_data*[13] __locales; 431 const(ushort)* __ctype_b; 432 const(int)* __ctype_tolower; 433 const(int)* __ctype_toupper; 434 const(char)*[13] __names; 435 } 436 437 struct _G_fpos_t 438 { 439 c_long __pos; 440 __mbstate_t __state; 441 } 442 443 alias __fpos_t = _G_fpos_t; 444 extern __gshared _IO_FILE* stdin; 445 extern __gshared _IO_FILE* stdout; 446 extern __gshared _IO_FILE* stderr; 447 struct _G_fpos64_t 448 { 449 c_long __pos; 450 __mbstate_t __state; 451 } 452 453 alias __fpos64_t = _G_fpos64_t; 454 int remove(const(char)*) @nogc nothrow; 455 int rename(const(char)*, const(char)*) @nogc nothrow; 456 int renameat(int, const(char)*, int, const(char)*) @nogc nothrow; 457 _IO_FILE* tmpfile() @nogc nothrow; 458 char* tmpnam(char*) @nogc nothrow; 459 char* tmpnam_r(char*) @nogc nothrow; 460 char* tempnam(const(char)*, const(char)*) @nogc nothrow; 461 int fclose(_IO_FILE*) @nogc nothrow; 462 int fflush(_IO_FILE*) @nogc nothrow; 463 int fflush_unlocked(_IO_FILE*) @nogc nothrow; 464 _IO_FILE* fopen(const(char)*, const(char)*) @nogc nothrow; 465 _IO_FILE* freopen(const(char)*, const(char)*, _IO_FILE*) @nogc nothrow; 466 _IO_FILE* fdopen(int, const(char)*) @nogc nothrow; 467 _IO_FILE* fmemopen(void*, c_ulong, const(char)*) @nogc nothrow; 468 _IO_FILE* open_memstream(char**, c_ulong*) @nogc nothrow; 469 void setbuf(_IO_FILE*, char*) @nogc nothrow; 470 int setvbuf(_IO_FILE*, char*, int, c_ulong) @nogc nothrow; 471 void setbuffer(_IO_FILE*, char*, c_ulong) @nogc nothrow; 472 void setlinebuf(_IO_FILE*) @nogc nothrow; 473 int fprintf(_IO_FILE*, const(char)*, ...) @nogc nothrow; 474 int printf(const(char)*, ...) @nogc nothrow; 475 int sprintf(char*, const(char)*, ...) @nogc nothrow; 476 int vfprintf(_IO_FILE*, const(char)*, va_list*) @nogc nothrow; 477 int vprintf(const(char)*, va_list*) @nogc nothrow; 478 int vsprintf(char*, const(char)*, va_list*) @nogc nothrow; 479 int snprintf(char*, c_ulong, const(char)*, ...) @nogc nothrow; 480 int vsnprintf(char*, c_ulong, const(char)*, va_list*) @nogc nothrow; 481 int vdprintf(int, const(char)*, va_list*) @nogc nothrow; 482 int dprintf(int, const(char)*, ...) @nogc nothrow; 483 int fscanf(_IO_FILE*, const(char)*, ...) @nogc nothrow; 484 int scanf(const(char)*, ...) @nogc nothrow; 485 int sscanf(const(char)*, const(char)*, ...) @nogc nothrow; 486 int vfscanf(_IO_FILE*, const(char)*, va_list*) @nogc nothrow; 487 int vscanf(const(char)*, va_list*) @nogc nothrow; 488 int vsscanf(const(char)*, const(char)*, va_list*) @nogc nothrow; 489 int fgetc(_IO_FILE*) @nogc nothrow; 490 int getc(_IO_FILE*) @nogc nothrow; 491 int getchar() @nogc nothrow; 492 int getc_unlocked(_IO_FILE*) @nogc nothrow; 493 int getchar_unlocked() @nogc nothrow; 494 int fgetc_unlocked(_IO_FILE*) @nogc nothrow; 495 int fputc(int, _IO_FILE*) @nogc nothrow; 496 int putc(int, _IO_FILE*) @nogc nothrow; 497 int putchar(int) @nogc nothrow; 498 int fputc_unlocked(int, _IO_FILE*) @nogc nothrow; 499 int putc_unlocked(int, _IO_FILE*) @nogc nothrow; 500 int putchar_unlocked(int) @nogc nothrow; 501 int getw(_IO_FILE*) @nogc nothrow; 502 int putw(int, _IO_FILE*) @nogc nothrow; 503 char* fgets(char*, int, _IO_FILE*) @nogc nothrow; 504 c_long __getdelim(char**, c_ulong*, int, _IO_FILE*) @nogc nothrow; 505 c_long getdelim(char**, c_ulong*, int, _IO_FILE*) @nogc nothrow; 506 c_long getline(char**, c_ulong*, _IO_FILE*) @nogc nothrow; 507 int fputs(const(char)*, _IO_FILE*) @nogc nothrow; 508 int puts(const(char)*) @nogc nothrow; 509 int ungetc(int, _IO_FILE*) @nogc nothrow; 510 c_ulong fread(void*, c_ulong, c_ulong, _IO_FILE*) @nogc nothrow; 511 c_ulong fwrite(const(void)*, c_ulong, c_ulong, _IO_FILE*) @nogc nothrow; 512 c_ulong fread_unlocked(void*, c_ulong, c_ulong, _IO_FILE*) @nogc nothrow; 513 c_ulong fwrite_unlocked(const(void)*, c_ulong, c_ulong, _IO_FILE*) @nogc nothrow; 514 int fseek(_IO_FILE*, c_long, int) @nogc nothrow; 515 c_long ftell(_IO_FILE*) @nogc nothrow; 516 void rewind(_IO_FILE*) @nogc nothrow; 517 int fseeko(_IO_FILE*, c_long, int) @nogc nothrow; 518 c_long ftello(_IO_FILE*) @nogc nothrow; 519 int fgetpos(_IO_FILE*, _G_fpos_t*) @nogc nothrow; 520 int fsetpos(_IO_FILE*, const(_G_fpos_t)*) @nogc nothrow; 521 void clearerr(_IO_FILE*) @nogc nothrow; 522 int feof(_IO_FILE*) @nogc nothrow; 523 int ferror(_IO_FILE*) @nogc nothrow; 524 void clearerr_unlocked(_IO_FILE*) @nogc nothrow; 525 int feof_unlocked(_IO_FILE*) @nogc nothrow; 526 int ferror_unlocked(_IO_FILE*) @nogc nothrow; 527 void perror(const(char)*) @nogc nothrow; 528 int fileno(_IO_FILE*) @nogc nothrow; 529 int fileno_unlocked(_IO_FILE*) @nogc nothrow; 530 _IO_FILE* popen(const(char)*, const(char)*) @nogc nothrow; 531 int pclose(_IO_FILE*) @nogc nothrow; 532 char* ctermid(char*) @nogc nothrow; 533 void flockfile(_IO_FILE*) @nogc nothrow; 534 int ftrylockfile(_IO_FILE*) @nogc nothrow; 535 void funlockfile(_IO_FILE*) @nogc nothrow; 536 int __uflow(_IO_FILE*) @nogc nothrow; 537 int __overflow(_IO_FILE*, int) @nogc nothrow; 538 alias __FILE = _IO_FILE; 539 struct sigevent; 540 struct _IO_FILE 541 { 542 int _flags; 543 char* _IO_read_ptr; 544 char* _IO_read_end; 545 char* _IO_read_base; 546 char* _IO_write_base; 547 char* _IO_write_ptr; 548 char* _IO_write_end; 549 char* _IO_buf_base; 550 char* _IO_buf_end; 551 char* _IO_save_base; 552 char* _IO_backup_base; 553 char* _IO_save_end; 554 _IO_marker* _markers; 555 _IO_FILE* _chain; 556 int _fileno; 557 int _flags2; 558 c_long _old_offset; 559 ushort _cur_column; 560 byte _vtable_offset; 561 char[1] _shortbuf; 562 void* _lock; 563 c_long _offset; 564 _IO_codecvt* _codecvt; 565 _IO_wide_data* _wide_data; 566 _IO_FILE* _freeres_list; 567 void* _freeres_buf; 568 c_ulong __pad5; 569 int _mode; 570 char[20] _unused2; 571 } 572 573 c_long clock() @nogc nothrow; 574 c_long time(c_long*) @nogc nothrow; 575 double difftime(c_long, c_long) @nogc nothrow; 576 c_long mktime(tm*) @nogc nothrow; 577 c_ulong strftime(char*, c_ulong, const(char)*, const(tm)*) @nogc nothrow; 578 c_ulong strftime_l(char*, c_ulong, const(char)*, const(tm)*, __locale_struct*) @nogc nothrow; 579 tm* gmtime(const(c_long)*) @nogc nothrow; 580 tm* localtime(const(c_long)*) @nogc nothrow; 581 tm* gmtime_r(const(c_long)*, tm*) @nogc nothrow; 582 tm* localtime_r(const(c_long)*, tm*) @nogc nothrow; 583 char* asctime(const(tm)*) @nogc nothrow; 584 char* ctime(const(c_long)*) @nogc nothrow; 585 char* asctime_r(const(tm)*, char*) @nogc nothrow; 586 char* ctime_r(const(c_long)*, char*) @nogc nothrow; 587 extern __gshared char*[2] __tzname; 588 extern __gshared int __daylight; 589 extern __gshared c_long __timezone; 590 extern __gshared char*[2] tzname; 591 void tzset() @nogc nothrow; 592 extern __gshared int daylight; 593 extern __gshared c_long timezone; 594 alias FILE = _IO_FILE; 595 c_long timegm(tm*) @nogc nothrow; 596 c_long timelocal(tm*) @nogc nothrow; 597 int dysize(int) @nogc nothrow; 598 int nanosleep(const(timespec)*, timespec*) @nogc nothrow; 599 int clock_getres(int, timespec*) @nogc nothrow; 600 int clock_gettime(int, timespec*) @nogc nothrow; 601 int clock_settime(int, const(timespec)*) @nogc nothrow; 602 int clock_nanosleep(int, int, const(timespec)*, timespec*) @nogc nothrow; 603 int clock_getcpuclockid(int, int*) @nogc nothrow; 604 int timer_create(int, sigevent*, void**) @nogc nothrow; 605 int timer_delete(void*) @nogc nothrow; 606 int timer_settime(void*, int, const(itimerspec)*, itimerspec*) @nogc nothrow; 607 int timer_gettime(void*, itimerspec*) @nogc nothrow; 608 int timer_getoverrun(void*) @nogc nothrow; 609 int timespec_get(timespec*, int) @nogc nothrow; 610 static ushort __bswap_16(ushort) @nogc nothrow; 611 alias __sig_atomic_t = int; 612 static uint __bswap_32(uint) @nogc nothrow; 613 static c_ulong __bswap_64(c_ulong) @nogc nothrow; 614 alias __socklen_t = uint; 615 alias __intptr_t = c_long; 616 alias __caddr_t = char*; 617 alias __loff_t = c_long; 618 alias __syscall_ulong_t = c_ulong; 619 alias __syscall_slong_t = c_long; 620 alias __ssize_t = c_long; 621 alias __fsword_t = c_long; 622 alias __fsfilcnt64_t = c_ulong; 623 alias __fsfilcnt_t = c_ulong; 624 alias __fsblkcnt64_t = c_ulong; 625 alias __fsblkcnt_t = c_ulong; 626 alias __blkcnt64_t = c_long; 627 alias pthread_t = c_ulong; 628 union pthread_mutexattr_t 629 { 630 char[4] __size; 631 int __align; 632 } 633 634 union pthread_condattr_t 635 { 636 char[4] __size; 637 int __align; 638 } 639 640 alias pthread_key_t = uint; 641 alias pthread_once_t = int; 642 union pthread_attr_t 643 { 644 char[56] __size; 645 c_long __align; 646 } 647 648 union pthread_mutex_t 649 { 650 __pthread_mutex_s __data; 651 char[40] __size; 652 c_long __align; 653 } 654 655 union pthread_cond_t 656 { 657 __pthread_cond_s __data; 658 char[48] __size; 659 long __align; 660 } 661 662 union pthread_rwlock_t 663 { 664 __pthread_rwlock_arch_t __data; 665 char[56] __size; 666 c_long __align; 667 } 668 669 union pthread_rwlockattr_t 670 { 671 char[8] __size; 672 c_long __align; 673 } 674 675 alias pthread_spinlock_t = int; 676 union pthread_barrier_t 677 { 678 char[32] __size; 679 c_long __align; 680 } 681 682 union pthread_barrierattr_t 683 { 684 char[4] __size; 685 int __align; 686 } 687 688 alias __blkcnt_t = c_long; 689 alias __blksize_t = c_long; 690 alias int8_t = byte; 691 alias int16_t = short; 692 alias int32_t = int; 693 alias int64_t = c_long; 694 alias uint8_t = ubyte; 695 alias uint16_t = ushort; 696 alias uint32_t = uint; 697 alias uint64_t = ulong; 698 alias __timer_t = void*; 699 alias __clockid_t = int; 700 alias __key_t = int; 701 struct __pthread_mutex_s 702 { 703 int __lock; 704 uint __count; 705 int __owner; 706 uint __nusers; 707 int __kind; 708 short __spins; 709 short __elision; 710 __pthread_internal_list __list; 711 } 712 713 alias __daddr_t = int; 714 struct __pthread_rwlock_arch_t 715 { 716 uint __readers; 717 uint __writers; 718 uint __wrphase_futex; 719 uint __writers_futex; 720 uint __pad3; 721 uint __pad4; 722 int __cur_writer; 723 int __shared; 724 byte __rwelision; 725 ubyte[7] __pad1; 726 c_ulong __pad2; 727 uint __flags; 728 } 729 730 alias __suseconds_t = c_long; 731 extern __gshared int sys_nerr; 732 extern __gshared const(const(char)*)[0] sys_errlist; 733 alias __pthread_list_t = __pthread_internal_list; 734 struct __pthread_internal_list 735 { 736 __pthread_internal_list* __prev; 737 __pthread_internal_list* __next; 738 } 739 740 alias __pthread_slist_t = __pthread_internal_slist; 741 struct __pthread_internal_slist 742 { 743 __pthread_internal_slist* __next; 744 } 745 746 struct __pthread_cond_s 747 { 748 static union _Anonymous_1 749 { 750 ulong __wseq; 751 static struct _Anonymous_2 752 { 753 uint __low; 754 uint __high; 755 } 756 757 _Anonymous_2 __wseq32; 758 } 759 760 _Anonymous_1 _anonymous_3; 761 auto __wseq() @property @nogc pure nothrow 762 { 763 return _anonymous_3.__wseq; 764 } 765 766 void __wseq(_T_)(auto ref _T_ val) @property @nogc pure nothrow 767 { 768 _anonymous_3.__wseq = val; 769 } 770 771 auto __wseq32() @property @nogc pure nothrow 772 { 773 return _anonymous_3.__wseq32; 774 } 775 776 void __wseq32(_T_)(auto ref _T_ val) @property @nogc pure nothrow 777 { 778 _anonymous_3.__wseq32 = val; 779 } 780 781 static union _Anonymous_4 782 { 783 ulong __g1_start; 784 static struct _Anonymous_5 785 { 786 uint __low; 787 uint __high; 788 } 789 790 _Anonymous_5 __g1_start32; 791 } 792 793 _Anonymous_4 _anonymous_6; 794 auto __g1_start() @property @nogc pure nothrow 795 { 796 return _anonymous_6.__g1_start; 797 } 798 799 void __g1_start(_T_)(auto ref _T_ val) @property @nogc pure nothrow 800 { 801 _anonymous_6.__g1_start = val; 802 } 803 804 auto __g1_start32() @property @nogc pure nothrow 805 { 806 return _anonymous_6.__g1_start32; 807 } 808 809 void __g1_start32(_T_)(auto ref _T_ val) @property @nogc pure nothrow 810 { 811 _anonymous_6.__g1_start32 = val; 812 } 813 814 uint[2] __g_refs; 815 uint[2] __g_size; 816 uint __g1_orig_size; 817 uint __wrefs; 818 uint[2] __g_signals; 819 } 820 821 alias __useconds_t = uint; 822 alias __time_t = c_long; 823 alias __id_t = uint; 824 alias __rlim64_t = c_ulong; 825 alias __rlim_t = c_ulong; 826 alias __clock_t = c_long; 827 alias __u_char = ubyte; 828 alias __u_short = ushort; 829 alias __u_int = uint; 830 alias __u_long = c_ulong; 831 alias __int8_t = byte; 832 alias __uint8_t = ubyte; 833 alias __int16_t = short; 834 alias __uint16_t = ushort; 835 alias __int32_t = int; 836 alias __uint32_t = uint; 837 alias __int64_t = c_long; 838 alias __uint64_t = c_ulong; 839 alias __int_least8_t = byte; 840 alias __uint_least8_t = ubyte; 841 alias __int_least16_t = short; 842 alias __uint_least16_t = ushort; 843 alias __int_least32_t = int; 844 alias __uint_least32_t = uint; 845 alias __int_least64_t = c_long; 846 alias __uint_least64_t = c_ulong; 847 alias __quad_t = c_long; 848 alias __u_quad_t = c_ulong; 849 alias __intmax_t = c_long; 850 alias __uintmax_t = c_ulong; 851 struct __fsid_t 852 { 853 int[2] __val; 854 } 855 856 alias __pid_t = int; 857 alias __off64_t = c_long; 858 alias __off_t = c_long; 859 alias __nlink_t = c_ulong; 860 alias __dev_t = c_ulong; 861 alias __uid_t = uint; 862 alias __gid_t = uint; 863 alias __ino_t = c_ulong; 864 alias __ino64_t = c_ulong; 865 alias __mode_t = uint; 866 867 static if (!is(typeof(__STD_TYPE))) 868 { 869 private enum enumMixinStr___STD_TYPE = `enum __STD_TYPE = typedef;`; 870 static if (is(typeof({ mixin(enumMixinStr___STD_TYPE); }))) 871 { 872 mixin(enumMixinStr___STD_TYPE); 873 } 874 } 875 876 static if (!is(typeof(__U64_TYPE))) 877 { 878 private enum enumMixinStr___U64_TYPE = `enum __U64_TYPE = unsigned long int;`; 879 static if (is(typeof({ mixin(enumMixinStr___U64_TYPE); }))) 880 { 881 mixin(enumMixinStr___U64_TYPE); 882 } 883 } 884 885 static if (!is(typeof(__S64_TYPE))) 886 { 887 private enum enumMixinStr___S64_TYPE = `enum __S64_TYPE = long int;`; 888 static if (is(typeof({ mixin(enumMixinStr___S64_TYPE); }))) 889 { 890 mixin(enumMixinStr___S64_TYPE); 891 } 892 } 893 894 static if (!is(typeof(__ULONG32_TYPE))) 895 { 896 private enum enumMixinStr___ULONG32_TYPE = `enum __ULONG32_TYPE = unsigned int;`; 897 static if (is(typeof({ mixin(enumMixinStr___ULONG32_TYPE); }))) 898 { 899 mixin(enumMixinStr___ULONG32_TYPE); 900 } 901 } 902 903 static if (!is(typeof(__SLONG32_TYPE))) 904 { 905 private enum enumMixinStr___SLONG32_TYPE = `enum __SLONG32_TYPE = int;`; 906 static if (is(typeof({ mixin(enumMixinStr___SLONG32_TYPE); }))) 907 { 908 mixin(enumMixinStr___SLONG32_TYPE); 909 } 910 } 911 912 static if (!is(typeof(__UWORD_TYPE))) 913 { 914 private enum enumMixinStr___UWORD_TYPE = `enum __UWORD_TYPE = unsigned long int;`; 915 static if (is(typeof({ mixin(enumMixinStr___UWORD_TYPE); }))) 916 { 917 mixin(enumMixinStr___UWORD_TYPE); 918 } 919 } 920 921 static if (!is(typeof(__SWORD_TYPE))) 922 { 923 private enum enumMixinStr___SWORD_TYPE = `enum __SWORD_TYPE = long int;`; 924 static if (is(typeof({ mixin(enumMixinStr___SWORD_TYPE); }))) 925 { 926 mixin(enumMixinStr___SWORD_TYPE); 927 } 928 } 929 930 static if (!is(typeof(__UQUAD_TYPE))) 931 { 932 private enum enumMixinStr___UQUAD_TYPE = `enum __UQUAD_TYPE = unsigned long int;`; 933 static if (is(typeof({ mixin(enumMixinStr___UQUAD_TYPE); }))) 934 { 935 mixin(enumMixinStr___UQUAD_TYPE); 936 } 937 } 938 939 static if (!is(typeof(__SQUAD_TYPE))) 940 { 941 private enum enumMixinStr___SQUAD_TYPE = `enum __SQUAD_TYPE = long int;`; 942 static if (is(typeof({ mixin(enumMixinStr___SQUAD_TYPE); }))) 943 { 944 mixin(enumMixinStr___SQUAD_TYPE); 945 } 946 } 947 948 static if (!is(typeof(__ULONGWORD_TYPE))) 949 { 950 private enum enumMixinStr___ULONGWORD_TYPE = `enum __ULONGWORD_TYPE = unsigned long int;`; 951 static if (is(typeof({ mixin(enumMixinStr___ULONGWORD_TYPE); }))) 952 { 953 mixin(enumMixinStr___ULONGWORD_TYPE); 954 } 955 } 956 957 static if (!is(typeof(__SLONGWORD_TYPE))) 958 { 959 private enum enumMixinStr___SLONGWORD_TYPE = `enum __SLONGWORD_TYPE = long int;`; 960 static if (is(typeof({ mixin(enumMixinStr___SLONGWORD_TYPE); }))) 961 { 962 mixin(enumMixinStr___SLONGWORD_TYPE); 963 } 964 } 965 966 static if (!is(typeof(__U32_TYPE))) 967 { 968 private enum enumMixinStr___U32_TYPE = `enum __U32_TYPE = unsigned int;`; 969 static if (is(typeof({ mixin(enumMixinStr___U32_TYPE); }))) 970 { 971 mixin(enumMixinStr___U32_TYPE); 972 } 973 } 974 975 static if (!is(typeof(__S32_TYPE))) 976 { 977 private enum enumMixinStr___S32_TYPE = `enum __S32_TYPE = int;`; 978 static if (is(typeof({ mixin(enumMixinStr___S32_TYPE); }))) 979 { 980 mixin(enumMixinStr___S32_TYPE); 981 } 982 } 983 984 static if (!is(typeof(__U16_TYPE))) 985 { 986 private enum enumMixinStr___U16_TYPE = `enum __U16_TYPE = unsigned short int;`; 987 static if (is(typeof({ mixin(enumMixinStr___U16_TYPE); }))) 988 { 989 mixin(enumMixinStr___U16_TYPE); 990 } 991 } 992 993 static if (!is(typeof(__S16_TYPE))) 994 { 995 private enum enumMixinStr___S16_TYPE = `enum __S16_TYPE = short int;`; 996 static if (is(typeof({ mixin(enumMixinStr___S16_TYPE); }))) 997 { 998 mixin(enumMixinStr___S16_TYPE); 999 } 1000 } 1001 1002 static if (!is(typeof(_BITS_TYPES_H))) 1003 { 1004 private enum enumMixinStr__BITS_TYPES_H = `enum _BITS_TYPES_H = 1;`; 1005 static if (is(typeof({ mixin(enumMixinStr__BITS_TYPES_H); }))) 1006 { 1007 mixin(enumMixinStr__BITS_TYPES_H); 1008 } 1009 } 1010 1011 static if (!is(typeof(__TIMESIZE))) 1012 { 1013 private enum enumMixinStr___TIMESIZE = `enum __TIMESIZE = __WORDSIZE;`; 1014 static if (is(typeof({ mixin(enumMixinStr___TIMESIZE); }))) 1015 { 1016 mixin(enumMixinStr___TIMESIZE); 1017 } 1018 } 1019 1020 static if (!is(typeof(__TIME64_T_TYPE))) 1021 { 1022 private enum enumMixinStr___TIME64_T_TYPE = `enum __TIME64_T_TYPE = __TIME_T_TYPE;`; 1023 static if (is(typeof({ mixin(enumMixinStr___TIME64_T_TYPE); }))) 1024 { 1025 mixin(enumMixinStr___TIME64_T_TYPE); 1026 } 1027 } 1028 1029 static if (!is(typeof(_BITS_TIME64_H))) 1030 { 1031 private enum enumMixinStr__BITS_TIME64_H = `enum _BITS_TIME64_H = 1;`; 1032 static if (is(typeof({ mixin(enumMixinStr__BITS_TIME64_H); }))) 1033 { 1034 mixin(enumMixinStr__BITS_TIME64_H); 1035 } 1036 } 1037 1038 static if (!is(typeof(TIMER_ABSTIME))) 1039 { 1040 private enum enumMixinStr_TIMER_ABSTIME = `enum TIMER_ABSTIME = 1;`; 1041 static if (is(typeof({ mixin(enumMixinStr_TIMER_ABSTIME); }))) 1042 { 1043 mixin(enumMixinStr_TIMER_ABSTIME); 1044 } 1045 } 1046 1047 static if (!is(typeof(CLOCK_TAI))) 1048 { 1049 private enum enumMixinStr_CLOCK_TAI = `enum CLOCK_TAI = 11;`; 1050 static if (is(typeof({ mixin(enumMixinStr_CLOCK_TAI); }))) 1051 { 1052 mixin(enumMixinStr_CLOCK_TAI); 1053 } 1054 } 1055 1056 static if (!is(typeof(CLOCK_BOOTTIME_ALARM))) 1057 { 1058 private enum enumMixinStr_CLOCK_BOOTTIME_ALARM = `enum CLOCK_BOOTTIME_ALARM = 9;`; 1059 static if (is(typeof({ mixin(enumMixinStr_CLOCK_BOOTTIME_ALARM); }))) 1060 { 1061 mixin(enumMixinStr_CLOCK_BOOTTIME_ALARM); 1062 } 1063 } 1064 1065 static if (!is(typeof(CLOCK_REALTIME_ALARM))) 1066 { 1067 private enum enumMixinStr_CLOCK_REALTIME_ALARM = `enum CLOCK_REALTIME_ALARM = 8;`; 1068 static if (is(typeof({ mixin(enumMixinStr_CLOCK_REALTIME_ALARM); }))) 1069 { 1070 mixin(enumMixinStr_CLOCK_REALTIME_ALARM); 1071 } 1072 } 1073 1074 static if (!is(typeof(CLOCK_BOOTTIME))) 1075 { 1076 private enum enumMixinStr_CLOCK_BOOTTIME = `enum CLOCK_BOOTTIME = 7;`; 1077 static if (is(typeof({ mixin(enumMixinStr_CLOCK_BOOTTIME); }))) 1078 { 1079 mixin(enumMixinStr_CLOCK_BOOTTIME); 1080 } 1081 } 1082 1083 static if (!is(typeof(CLOCK_MONOTONIC_COARSE))) 1084 { 1085 private enum enumMixinStr_CLOCK_MONOTONIC_COARSE = `enum CLOCK_MONOTONIC_COARSE = 6;`; 1086 static if (is(typeof({ mixin(enumMixinStr_CLOCK_MONOTONIC_COARSE); }))) 1087 { 1088 mixin(enumMixinStr_CLOCK_MONOTONIC_COARSE); 1089 } 1090 } 1091 1092 static if (!is(typeof(CLOCK_REALTIME_COARSE))) 1093 { 1094 private enum enumMixinStr_CLOCK_REALTIME_COARSE = `enum CLOCK_REALTIME_COARSE = 5;`; 1095 static if (is(typeof({ mixin(enumMixinStr_CLOCK_REALTIME_COARSE); }))) 1096 { 1097 mixin(enumMixinStr_CLOCK_REALTIME_COARSE); 1098 } 1099 } 1100 1101 static if (!is(typeof(CLOCK_MONOTONIC_RAW))) 1102 { 1103 private enum enumMixinStr_CLOCK_MONOTONIC_RAW = `enum CLOCK_MONOTONIC_RAW = 4;`; 1104 static if (is(typeof({ mixin(enumMixinStr_CLOCK_MONOTONIC_RAW); }))) 1105 { 1106 mixin(enumMixinStr_CLOCK_MONOTONIC_RAW); 1107 } 1108 } 1109 1110 static if (!is(typeof(CLOCK_THREAD_CPUTIME_ID))) 1111 { 1112 private enum enumMixinStr_CLOCK_THREAD_CPUTIME_ID = `enum CLOCK_THREAD_CPUTIME_ID = 3;`; 1113 static if (is(typeof({ mixin(enumMixinStr_CLOCK_THREAD_CPUTIME_ID); }))) 1114 { 1115 mixin(enumMixinStr_CLOCK_THREAD_CPUTIME_ID); 1116 } 1117 } 1118 1119 static if (!is(typeof(CLOCK_PROCESS_CPUTIME_ID))) 1120 { 1121 private enum enumMixinStr_CLOCK_PROCESS_CPUTIME_ID = `enum CLOCK_PROCESS_CPUTIME_ID = 2;`; 1122 static if (is(typeof({ mixin(enumMixinStr_CLOCK_PROCESS_CPUTIME_ID); }))) 1123 { 1124 mixin(enumMixinStr_CLOCK_PROCESS_CPUTIME_ID); 1125 } 1126 } 1127 1128 static if (!is(typeof(CLOCK_MONOTONIC))) 1129 { 1130 private enum enumMixinStr_CLOCK_MONOTONIC = `enum CLOCK_MONOTONIC = 1;`; 1131 static if (is(typeof({ mixin(enumMixinStr_CLOCK_MONOTONIC); }))) 1132 { 1133 mixin(enumMixinStr_CLOCK_MONOTONIC); 1134 } 1135 } 1136 1137 static if (!is(typeof(CLOCK_REALTIME))) 1138 { 1139 private enum enumMixinStr_CLOCK_REALTIME = `enum CLOCK_REALTIME = 0;`; 1140 static if (is(typeof({ mixin(enumMixinStr_CLOCK_REALTIME); }))) 1141 { 1142 mixin(enumMixinStr_CLOCK_REALTIME); 1143 } 1144 } 1145 1146 static if (!is(typeof(CLOCKS_PER_SEC))) 1147 { 1148 private enum enumMixinStr_CLOCKS_PER_SEC = `enum CLOCKS_PER_SEC = ( cast( __clock_t ) 1000000 );`; 1149 static if (is(typeof({ mixin(enumMixinStr_CLOCKS_PER_SEC); }))) 1150 { 1151 mixin(enumMixinStr_CLOCKS_PER_SEC); 1152 } 1153 } 1154 1155 static if (!is(typeof(_BITS_TIME_H))) 1156 { 1157 private enum enumMixinStr__BITS_TIME_H = `enum _BITS_TIME_H = 1;`; 1158 static if (is(typeof({ mixin(enumMixinStr__BITS_TIME_H); }))) 1159 { 1160 mixin(enumMixinStr__BITS_TIME_H); 1161 } 1162 } 1163 1164 static if (!is(typeof(_THREAD_SHARED_TYPES_H))) 1165 { 1166 private enum enumMixinStr__THREAD_SHARED_TYPES_H = `enum _THREAD_SHARED_TYPES_H = 1;`; 1167 static if (is(typeof({ mixin(enumMixinStr__THREAD_SHARED_TYPES_H); }))) 1168 { 1169 mixin(enumMixinStr__THREAD_SHARED_TYPES_H); 1170 } 1171 } 1172 1173 static if (!is(typeof(__PTHREAD_RWLOCK_ELISION_EXTRA))) 1174 { 1175 private enum enumMixinStr___PTHREAD_RWLOCK_ELISION_EXTRA = `enum __PTHREAD_RWLOCK_ELISION_EXTRA = 0 , { 0 , 0 , 0 , 0 , 0 , 0 , 0 };`; 1176 static if (is(typeof({ 1177 mixin(enumMixinStr___PTHREAD_RWLOCK_ELISION_EXTRA); 1178 }))) 1179 { 1180 mixin(enumMixinStr___PTHREAD_RWLOCK_ELISION_EXTRA); 1181 } 1182 } 1183 static if (!is(typeof(__PTHREAD_MUTEX_HAVE_PREV))) 1184 { 1185 private enum enumMixinStr___PTHREAD_MUTEX_HAVE_PREV = `enum __PTHREAD_MUTEX_HAVE_PREV = 1;`; 1186 static if (is(typeof({ mixin(enumMixinStr___PTHREAD_MUTEX_HAVE_PREV); }))) 1187 { 1188 mixin(enumMixinStr___PTHREAD_MUTEX_HAVE_PREV); 1189 } 1190 } 1191 1192 static if (!is(typeof(_THREAD_MUTEX_INTERNAL_H))) 1193 { 1194 private enum enumMixinStr__THREAD_MUTEX_INTERNAL_H = `enum _THREAD_MUTEX_INTERNAL_H = 1;`; 1195 static if (is(typeof({ mixin(enumMixinStr__THREAD_MUTEX_INTERNAL_H); }))) 1196 { 1197 mixin(enumMixinStr__THREAD_MUTEX_INTERNAL_H); 1198 } 1199 } 1200 1201 static if (!is(typeof(FOPEN_MAX))) 1202 { 1203 private enum enumMixinStr_FOPEN_MAX = `enum FOPEN_MAX = 16;`; 1204 static if (is(typeof({ mixin(enumMixinStr_FOPEN_MAX); }))) 1205 { 1206 mixin(enumMixinStr_FOPEN_MAX); 1207 } 1208 } 1209 1210 static if (!is(typeof(L_ctermid))) 1211 { 1212 private enum enumMixinStr_L_ctermid = `enum L_ctermid = 9;`; 1213 static if (is(typeof({ mixin(enumMixinStr_L_ctermid); }))) 1214 { 1215 mixin(enumMixinStr_L_ctermid); 1216 } 1217 } 1218 1219 static if (!is(typeof(FILENAME_MAX))) 1220 { 1221 private enum enumMixinStr_FILENAME_MAX = `enum FILENAME_MAX = 4096;`; 1222 static if (is(typeof({ mixin(enumMixinStr_FILENAME_MAX); }))) 1223 { 1224 mixin(enumMixinStr_FILENAME_MAX); 1225 } 1226 } 1227 1228 static if (!is(typeof(TMP_MAX))) 1229 { 1230 private enum enumMixinStr_TMP_MAX = `enum TMP_MAX = 238328;`; 1231 static if (is(typeof({ mixin(enumMixinStr_TMP_MAX); }))) 1232 { 1233 mixin(enumMixinStr_TMP_MAX); 1234 } 1235 } 1236 1237 static if (!is(typeof(L_tmpnam))) 1238 { 1239 private enum enumMixinStr_L_tmpnam = `enum L_tmpnam = 20;`; 1240 static if (is(typeof({ mixin(enumMixinStr_L_tmpnam); }))) 1241 { 1242 mixin(enumMixinStr_L_tmpnam); 1243 } 1244 } 1245 1246 static if (!is(typeof(_BITS_STDIO_LIM_H))) 1247 { 1248 private enum enumMixinStr__BITS_STDIO_LIM_H = `enum _BITS_STDIO_LIM_H = 1;`; 1249 static if (is(typeof({ mixin(enumMixinStr__BITS_STDIO_LIM_H); }))) 1250 { 1251 mixin(enumMixinStr__BITS_STDIO_LIM_H); 1252 } 1253 } 1254 1255 static if (!is(typeof(_BITS_STDINT_UINTN_H))) 1256 { 1257 private enum enumMixinStr__BITS_STDINT_UINTN_H = `enum _BITS_STDINT_UINTN_H = 1;`; 1258 static if (is(typeof({ mixin(enumMixinStr__BITS_STDINT_UINTN_H); }))) 1259 { 1260 mixin(enumMixinStr__BITS_STDINT_UINTN_H); 1261 } 1262 } 1263 1264 static if (!is(typeof(_BITS_STDINT_INTN_H))) 1265 { 1266 private enum enumMixinStr__BITS_STDINT_INTN_H = `enum _BITS_STDINT_INTN_H = 1;`; 1267 static if (is(typeof({ mixin(enumMixinStr__BITS_STDINT_INTN_H); }))) 1268 { 1269 mixin(enumMixinStr__BITS_STDINT_INTN_H); 1270 } 1271 } 1272 static if (!is(typeof(__FD_ZERO_STOS))) 1273 { 1274 private enum enumMixinStr___FD_ZERO_STOS = `enum __FD_ZERO_STOS = "stosq";`; 1275 static if (is(typeof({ mixin(enumMixinStr___FD_ZERO_STOS); }))) 1276 { 1277 mixin(enumMixinStr___FD_ZERO_STOS); 1278 } 1279 } 1280 1281 static if (!is(typeof(__have_pthread_attr_t))) 1282 { 1283 private enum enumMixinStr___have_pthread_attr_t = `enum __have_pthread_attr_t = 1;`; 1284 static if (is(typeof({ mixin(enumMixinStr___have_pthread_attr_t); }))) 1285 { 1286 mixin(enumMixinStr___have_pthread_attr_t); 1287 } 1288 } 1289 1290 static if (!is(typeof(_BITS_PTHREADTYPES_COMMON_H))) 1291 { 1292 private enum enumMixinStr__BITS_PTHREADTYPES_COMMON_H = `enum _BITS_PTHREADTYPES_COMMON_H = 1;`; 1293 static if (is(typeof({ mixin(enumMixinStr__BITS_PTHREADTYPES_COMMON_H); }))) 1294 { 1295 mixin(enumMixinStr__BITS_PTHREADTYPES_COMMON_H); 1296 } 1297 } 1298 static if (!is(typeof(__SIZEOF_PTHREAD_BARRIERATTR_T))) 1299 { 1300 private enum enumMixinStr___SIZEOF_PTHREAD_BARRIERATTR_T = `enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;`; 1301 static if (is(typeof({ 1302 mixin(enumMixinStr___SIZEOF_PTHREAD_BARRIERATTR_T); 1303 }))) 1304 { 1305 mixin(enumMixinStr___SIZEOF_PTHREAD_BARRIERATTR_T); 1306 } 1307 } 1308 1309 static if (!is(typeof(__SIZEOF_PTHREAD_RWLOCKATTR_T))) 1310 { 1311 private enum enumMixinStr___SIZEOF_PTHREAD_RWLOCKATTR_T = `enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;`; 1312 static if (is(typeof({ 1313 mixin(enumMixinStr___SIZEOF_PTHREAD_RWLOCKATTR_T); 1314 }))) 1315 { 1316 mixin(enumMixinStr___SIZEOF_PTHREAD_RWLOCKATTR_T); 1317 } 1318 } 1319 1320 static if (!is(typeof(__SIZEOF_PTHREAD_CONDATTR_T))) 1321 { 1322 private enum enumMixinStr___SIZEOF_PTHREAD_CONDATTR_T = `enum __SIZEOF_PTHREAD_CONDATTR_T = 4;`; 1323 static if (is(typeof({ mixin(enumMixinStr___SIZEOF_PTHREAD_CONDATTR_T); }))) 1324 { 1325 mixin(enumMixinStr___SIZEOF_PTHREAD_CONDATTR_T); 1326 } 1327 } 1328 1329 static if (!is(typeof(__SIZEOF_PTHREAD_COND_T))) 1330 { 1331 private enum enumMixinStr___SIZEOF_PTHREAD_COND_T = `enum __SIZEOF_PTHREAD_COND_T = 48;`; 1332 static if (is(typeof({ mixin(enumMixinStr___SIZEOF_PTHREAD_COND_T); }))) 1333 { 1334 mixin(enumMixinStr___SIZEOF_PTHREAD_COND_T); 1335 } 1336 } 1337 1338 static if (!is(typeof(__SIZEOF_PTHREAD_MUTEXATTR_T))) 1339 { 1340 private enum enumMixinStr___SIZEOF_PTHREAD_MUTEXATTR_T = `enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;`; 1341 static if (is(typeof({ mixin(enumMixinStr___SIZEOF_PTHREAD_MUTEXATTR_T); }))) 1342 { 1343 mixin(enumMixinStr___SIZEOF_PTHREAD_MUTEXATTR_T); 1344 } 1345 } 1346 1347 static if (!is(typeof(__SIZEOF_PTHREAD_BARRIER_T))) 1348 { 1349 private enum enumMixinStr___SIZEOF_PTHREAD_BARRIER_T = `enum __SIZEOF_PTHREAD_BARRIER_T = 32;`; 1350 static if (is(typeof({ mixin(enumMixinStr___SIZEOF_PTHREAD_BARRIER_T); }))) 1351 { 1352 mixin(enumMixinStr___SIZEOF_PTHREAD_BARRIER_T); 1353 } 1354 } 1355 1356 static if (!is(typeof(__SIZEOF_PTHREAD_RWLOCK_T))) 1357 { 1358 private enum enumMixinStr___SIZEOF_PTHREAD_RWLOCK_T = `enum __SIZEOF_PTHREAD_RWLOCK_T = 56;`; 1359 static if (is(typeof({ mixin(enumMixinStr___SIZEOF_PTHREAD_RWLOCK_T); }))) 1360 { 1361 mixin(enumMixinStr___SIZEOF_PTHREAD_RWLOCK_T); 1362 } 1363 } 1364 1365 static if (!is(typeof(__SIZEOF_PTHREAD_ATTR_T))) 1366 { 1367 private enum enumMixinStr___SIZEOF_PTHREAD_ATTR_T = `enum __SIZEOF_PTHREAD_ATTR_T = 56;`; 1368 static if (is(typeof({ mixin(enumMixinStr___SIZEOF_PTHREAD_ATTR_T); }))) 1369 { 1370 mixin(enumMixinStr___SIZEOF_PTHREAD_ATTR_T); 1371 } 1372 } 1373 1374 static if (!is(typeof(__SIZEOF_PTHREAD_MUTEX_T))) 1375 { 1376 private enum enumMixinStr___SIZEOF_PTHREAD_MUTEX_T = `enum __SIZEOF_PTHREAD_MUTEX_T = 40;`; 1377 static if (is(typeof({ mixin(enumMixinStr___SIZEOF_PTHREAD_MUTEX_T); }))) 1378 { 1379 mixin(enumMixinStr___SIZEOF_PTHREAD_MUTEX_T); 1380 } 1381 } 1382 1383 static if (!is(typeof(_BITS_PTHREADTYPES_ARCH_H))) 1384 { 1385 private enum enumMixinStr__BITS_PTHREADTYPES_ARCH_H = `enum _BITS_PTHREADTYPES_ARCH_H = 1;`; 1386 static if (is(typeof({ mixin(enumMixinStr__BITS_PTHREADTYPES_ARCH_H); }))) 1387 { 1388 mixin(enumMixinStr__BITS_PTHREADTYPES_ARCH_H); 1389 } 1390 } 1391 1392 static if (!is(typeof(__LONG_DOUBLE_USES_FLOAT128))) 1393 { 1394 private enum enumMixinStr___LONG_DOUBLE_USES_FLOAT128 = `enum __LONG_DOUBLE_USES_FLOAT128 = 0;`; 1395 static if (is(typeof({ mixin(enumMixinStr___LONG_DOUBLE_USES_FLOAT128); }))) 1396 { 1397 mixin(enumMixinStr___LONG_DOUBLE_USES_FLOAT128); 1398 } 1399 } 1400 1401 static if (!is(typeof(__GLIBC_USE_IEC_60559_TYPES_EXT))) 1402 { 1403 private enum enumMixinStr___GLIBC_USE_IEC_60559_TYPES_EXT = `enum __GLIBC_USE_IEC_60559_TYPES_EXT = 0;`; 1404 static if (is(typeof({ 1405 mixin(enumMixinStr___GLIBC_USE_IEC_60559_TYPES_EXT); 1406 }))) 1407 { 1408 mixin(enumMixinStr___GLIBC_USE_IEC_60559_TYPES_EXT); 1409 } 1410 } 1411 1412 static if (!is(typeof(__GLIBC_USE_IEC_60559_FUNCS_EXT_C2X))) 1413 { 1414 private enum enumMixinStr___GLIBC_USE_IEC_60559_FUNCS_EXT_C2X = `enum __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X = 0;`; 1415 static if (is(typeof({ 1416 mixin(enumMixinStr___GLIBC_USE_IEC_60559_FUNCS_EXT_C2X); 1417 }))) 1418 { 1419 mixin(enumMixinStr___GLIBC_USE_IEC_60559_FUNCS_EXT_C2X); 1420 } 1421 } 1422 1423 static if (!is(typeof(__GLIBC_USE_IEC_60559_FUNCS_EXT))) 1424 { 1425 private enum enumMixinStr___GLIBC_USE_IEC_60559_FUNCS_EXT = `enum __GLIBC_USE_IEC_60559_FUNCS_EXT = 0;`; 1426 static if (is(typeof({ 1427 mixin(enumMixinStr___GLIBC_USE_IEC_60559_FUNCS_EXT); 1428 }))) 1429 { 1430 mixin(enumMixinStr___GLIBC_USE_IEC_60559_FUNCS_EXT); 1431 } 1432 } 1433 1434 static if (!is(typeof(__GLIBC_USE_IEC_60559_BFP_EXT_C2X))) 1435 { 1436 private enum enumMixinStr___GLIBC_USE_IEC_60559_BFP_EXT_C2X = `enum __GLIBC_USE_IEC_60559_BFP_EXT_C2X = 0;`; 1437 static if (is(typeof({ 1438 mixin(enumMixinStr___GLIBC_USE_IEC_60559_BFP_EXT_C2X); 1439 }))) 1440 { 1441 mixin(enumMixinStr___GLIBC_USE_IEC_60559_BFP_EXT_C2X); 1442 } 1443 } 1444 1445 static if (!is(typeof(__GLIBC_USE_IEC_60559_BFP_EXT))) 1446 { 1447 private enum enumMixinStr___GLIBC_USE_IEC_60559_BFP_EXT = `enum __GLIBC_USE_IEC_60559_BFP_EXT = 0;`; 1448 static if (is(typeof({ 1449 mixin(enumMixinStr___GLIBC_USE_IEC_60559_BFP_EXT); 1450 }))) 1451 { 1452 mixin(enumMixinStr___GLIBC_USE_IEC_60559_BFP_EXT); 1453 } 1454 } 1455 1456 static if (!is(typeof(__GLIBC_USE_LIB_EXT2))) 1457 { 1458 private enum enumMixinStr___GLIBC_USE_LIB_EXT2 = `enum __GLIBC_USE_LIB_EXT2 = 0;`; 1459 static if (is(typeof({ mixin(enumMixinStr___GLIBC_USE_LIB_EXT2); }))) 1460 { 1461 mixin(enumMixinStr___GLIBC_USE_LIB_EXT2); 1462 } 1463 } 1464 1465 static if (!is(typeof(__BYTE_ORDER))) 1466 { 1467 private enum enumMixinStr___BYTE_ORDER = `enum __BYTE_ORDER = __LITTLE_ENDIAN;`; 1468 static if (is(typeof({ mixin(enumMixinStr___BYTE_ORDER); }))) 1469 { 1470 mixin(enumMixinStr___BYTE_ORDER); 1471 } 1472 } 1473 1474 static if (!is(typeof(_BITS_ENDIANNESS_H))) 1475 { 1476 private enum enumMixinStr__BITS_ENDIANNESS_H = `enum _BITS_ENDIANNESS_H = 1;`; 1477 static if (is(typeof({ mixin(enumMixinStr__BITS_ENDIANNESS_H); }))) 1478 { 1479 mixin(enumMixinStr__BITS_ENDIANNESS_H); 1480 } 1481 } 1482 1483 static if (!is(typeof(__FLOAT_WORD_ORDER))) 1484 { 1485 private enum enumMixinStr___FLOAT_WORD_ORDER = `enum __FLOAT_WORD_ORDER = __LITTLE_ENDIAN;`; 1486 static if (is(typeof({ mixin(enumMixinStr___FLOAT_WORD_ORDER); }))) 1487 { 1488 mixin(enumMixinStr___FLOAT_WORD_ORDER); 1489 } 1490 } 1491 1492 static if (!is(typeof(__PDP_ENDIAN))) 1493 { 1494 private enum enumMixinStr___PDP_ENDIAN = `enum __PDP_ENDIAN = 3412;`; 1495 static if (is(typeof({ mixin(enumMixinStr___PDP_ENDIAN); }))) 1496 { 1497 mixin(enumMixinStr___PDP_ENDIAN); 1498 } 1499 } 1500 1501 static if (!is(typeof(__BIG_ENDIAN))) 1502 { 1503 private enum enumMixinStr___BIG_ENDIAN = `enum __BIG_ENDIAN = 4321;`; 1504 static if (is(typeof({ mixin(enumMixinStr___BIG_ENDIAN); }))) 1505 { 1506 mixin(enumMixinStr___BIG_ENDIAN); 1507 } 1508 } 1509 1510 static if (!is(typeof(__LITTLE_ENDIAN))) 1511 { 1512 private enum enumMixinStr___LITTLE_ENDIAN = `enum __LITTLE_ENDIAN = 1234;`; 1513 static if (is(typeof({ mixin(enumMixinStr___LITTLE_ENDIAN); }))) 1514 { 1515 mixin(enumMixinStr___LITTLE_ENDIAN); 1516 } 1517 } 1518 1519 static if (!is(typeof(_BITS_ENDIAN_H))) 1520 { 1521 private enum enumMixinStr__BITS_ENDIAN_H = `enum _BITS_ENDIAN_H = 1;`; 1522 static if (is(typeof({ mixin(enumMixinStr__BITS_ENDIAN_H); }))) 1523 { 1524 mixin(enumMixinStr__BITS_ENDIAN_H); 1525 } 1526 } 1527 static if (!is(typeof(_BITS_BYTESWAP_H))) 1528 { 1529 private enum enumMixinStr__BITS_BYTESWAP_H = `enum _BITS_BYTESWAP_H = 1;`; 1530 static if (is(typeof({ mixin(enumMixinStr__BITS_BYTESWAP_H); }))) 1531 { 1532 mixin(enumMixinStr__BITS_BYTESWAP_H); 1533 } 1534 } 1535 1536 static if (!is(typeof(__FILE_defined))) 1537 { 1538 private enum enumMixinStr___FILE_defined = `enum __FILE_defined = 1;`; 1539 static if (is(typeof({ mixin(enumMixinStr___FILE_defined); }))) 1540 { 1541 mixin(enumMixinStr___FILE_defined); 1542 } 1543 } 1544 1545 static if (!is(typeof(____FILE_defined))) 1546 { 1547 private enum enumMixinStr_____FILE_defined = `enum ____FILE_defined = 1;`; 1548 static if (is(typeof({ mixin(enumMixinStr_____FILE_defined); }))) 1549 { 1550 mixin(enumMixinStr_____FILE_defined); 1551 } 1552 } 1553 1554 static if (!is(typeof(TIME_UTC))) 1555 { 1556 private enum enumMixinStr_TIME_UTC = `enum TIME_UTC = 1;`; 1557 static if (is(typeof({ mixin(enumMixinStr_TIME_UTC); }))) 1558 { 1559 mixin(enumMixinStr_TIME_UTC); 1560 } 1561 } 1562 1563 static if (!is(typeof(_____fpos64_t_defined))) 1564 { 1565 private enum enumMixinStr______fpos64_t_defined = `enum _____fpos64_t_defined = 1;`; 1566 static if (is(typeof({ mixin(enumMixinStr______fpos64_t_defined); }))) 1567 { 1568 mixin(enumMixinStr______fpos64_t_defined); 1569 } 1570 } 1571 1572 static if (!is(typeof(_TIME_H))) 1573 { 1574 private enum enumMixinStr__TIME_H = `enum _TIME_H = 1;`; 1575 static if (is(typeof({ mixin(enumMixinStr__TIME_H); }))) 1576 { 1577 mixin(enumMixinStr__TIME_H); 1578 } 1579 } 1580 1581 static if (!is(typeof(stderr))) 1582 { 1583 private enum enumMixinStr_stderr = `enum stderr = stderr;`; 1584 static if (is(typeof({ mixin(enumMixinStr_stderr); }))) 1585 { 1586 mixin(enumMixinStr_stderr); 1587 } 1588 } 1589 1590 static if (!is(typeof(stdout))) 1591 { 1592 private enum enumMixinStr_stdout = `enum stdout = stdout;`; 1593 static if (is(typeof({ mixin(enumMixinStr_stdout); }))) 1594 { 1595 mixin(enumMixinStr_stdout); 1596 } 1597 } 1598 1599 static if (!is(typeof(_____fpos_t_defined))) 1600 { 1601 private enum enumMixinStr______fpos_t_defined = `enum _____fpos_t_defined = 1;`; 1602 static if (is(typeof({ mixin(enumMixinStr______fpos_t_defined); }))) 1603 { 1604 mixin(enumMixinStr______fpos_t_defined); 1605 } 1606 } 1607 1608 static if (!is(typeof(stdin))) 1609 { 1610 private enum enumMixinStr_stdin = `enum stdin = stdin;`; 1611 static if (is(typeof({ mixin(enumMixinStr_stdin); }))) 1612 { 1613 mixin(enumMixinStr_stdin); 1614 } 1615 } 1616 1617 static if (!is(typeof(P_tmpdir))) 1618 { 1619 private enum enumMixinStr_P_tmpdir = `enum P_tmpdir = "/tmp";`; 1620 static if (is(typeof({ mixin(enumMixinStr_P_tmpdir); }))) 1621 { 1622 mixin(enumMixinStr_P_tmpdir); 1623 } 1624 } 1625 1626 static if (!is(typeof(SEEK_END))) 1627 { 1628 private enum enumMixinStr_SEEK_END = `enum SEEK_END = 2;`; 1629 static if (is(typeof({ mixin(enumMixinStr_SEEK_END); }))) 1630 { 1631 mixin(enumMixinStr_SEEK_END); 1632 } 1633 } 1634 1635 static if (!is(typeof(SEEK_CUR))) 1636 { 1637 private enum enumMixinStr_SEEK_CUR = `enum SEEK_CUR = 1;`; 1638 static if (is(typeof({ mixin(enumMixinStr_SEEK_CUR); }))) 1639 { 1640 mixin(enumMixinStr_SEEK_CUR); 1641 } 1642 } 1643 1644 static if (!is(typeof(_BITS_TYPES___LOCALE_T_H))) 1645 { 1646 private enum enumMixinStr__BITS_TYPES___LOCALE_T_H = `enum _BITS_TYPES___LOCALE_T_H = 1;`; 1647 static if (is(typeof({ mixin(enumMixinStr__BITS_TYPES___LOCALE_T_H); }))) 1648 { 1649 mixin(enumMixinStr__BITS_TYPES___LOCALE_T_H); 1650 } 1651 } 1652 1653 static if (!is(typeof(SEEK_SET))) 1654 { 1655 private enum enumMixinStr_SEEK_SET = `enum SEEK_SET = 0;`; 1656 static if (is(typeof({ mixin(enumMixinStr_SEEK_SET); }))) 1657 { 1658 mixin(enumMixinStr_SEEK_SET); 1659 } 1660 } 1661 1662 static if (!is(typeof(EOF))) 1663 { 1664 private enum enumMixinStr_EOF = `enum EOF = ( - 1 );`; 1665 static if (is(typeof({ mixin(enumMixinStr_EOF); }))) 1666 { 1667 mixin(enumMixinStr_EOF); 1668 } 1669 } 1670 1671 static if (!is(typeof(____mbstate_t_defined))) 1672 { 1673 private enum enumMixinStr_____mbstate_t_defined = `enum ____mbstate_t_defined = 1;`; 1674 static if (is(typeof({ mixin(enumMixinStr_____mbstate_t_defined); }))) 1675 { 1676 mixin(enumMixinStr_____mbstate_t_defined); 1677 } 1678 } 1679 1680 static if (!is(typeof(BUFSIZ))) 1681 { 1682 private enum enumMixinStr_BUFSIZ = `enum BUFSIZ = 8192;`; 1683 static if (is(typeof({ mixin(enumMixinStr_BUFSIZ); }))) 1684 { 1685 mixin(enumMixinStr_BUFSIZ); 1686 } 1687 } 1688 1689 static if (!is(typeof(_IONBF))) 1690 { 1691 private enum enumMixinStr__IONBF = `enum _IONBF = 2;`; 1692 static if (is(typeof({ mixin(enumMixinStr__IONBF); }))) 1693 { 1694 mixin(enumMixinStr__IONBF); 1695 } 1696 } 1697 1698 static if (!is(typeof(_IOLBF))) 1699 { 1700 private enum enumMixinStr__IOLBF = `enum _IOLBF = 1;`; 1701 static if (is(typeof({ mixin(enumMixinStr__IOLBF); }))) 1702 { 1703 mixin(enumMixinStr__IOLBF); 1704 } 1705 } 1706 1707 static if (!is(typeof(_IOFBF))) 1708 { 1709 private enum enumMixinStr__IOFBF = `enum _IOFBF = 0;`; 1710 static if (is(typeof({ mixin(enumMixinStr__IOFBF); }))) 1711 { 1712 mixin(enumMixinStr__IOFBF); 1713 } 1714 } 1715 1716 static if (!is(typeof(_SIGSET_NWORDS))) 1717 { 1718 private enum enumMixinStr__SIGSET_NWORDS = `enum _SIGSET_NWORDS = ( 1024 / ( 8 * ( unsigned long int ) .sizeof ) );`; 1719 static if (is(typeof({ mixin(enumMixinStr__SIGSET_NWORDS); }))) 1720 { 1721 mixin(enumMixinStr__SIGSET_NWORDS); 1722 } 1723 } 1724 static if (!is(typeof(__clock_t_defined))) 1725 { 1726 private enum enumMixinStr___clock_t_defined = `enum __clock_t_defined = 1;`; 1727 static if (is(typeof({ mixin(enumMixinStr___clock_t_defined); }))) 1728 { 1729 mixin(enumMixinStr___clock_t_defined); 1730 } 1731 } 1732 1733 static if (!is(typeof(__clockid_t_defined))) 1734 { 1735 private enum enumMixinStr___clockid_t_defined = `enum __clockid_t_defined = 1;`; 1736 static if (is(typeof({ mixin(enumMixinStr___clockid_t_defined); }))) 1737 { 1738 mixin(enumMixinStr___clockid_t_defined); 1739 } 1740 } 1741 1742 static if (!is(typeof(_BITS_TYPES_LOCALE_T_H))) 1743 { 1744 private enum enumMixinStr__BITS_TYPES_LOCALE_T_H = `enum _BITS_TYPES_LOCALE_T_H = 1;`; 1745 static if (is(typeof({ mixin(enumMixinStr__BITS_TYPES_LOCALE_T_H); }))) 1746 { 1747 mixin(enumMixinStr__BITS_TYPES_LOCALE_T_H); 1748 } 1749 } 1750 1751 static if (!is(typeof(_STDIO_H))) 1752 { 1753 private enum enumMixinStr__STDIO_H = `enum _STDIO_H = 1;`; 1754 static if (is(typeof({ mixin(enumMixinStr__STDIO_H); }))) 1755 { 1756 mixin(enumMixinStr__STDIO_H); 1757 } 1758 } 1759 1760 static if (!is(typeof(__sigset_t_defined))) 1761 { 1762 private enum enumMixinStr___sigset_t_defined = `enum __sigset_t_defined = 1;`; 1763 static if (is(typeof({ mixin(enumMixinStr___sigset_t_defined); }))) 1764 { 1765 mixin(enumMixinStr___sigset_t_defined); 1766 } 1767 } 1768 static if (!is(typeof(__struct_FILE_defined))) 1769 { 1770 private enum enumMixinStr___struct_FILE_defined = `enum __struct_FILE_defined = 1;`; 1771 static if (is(typeof({ mixin(enumMixinStr___struct_FILE_defined); }))) 1772 { 1773 mixin(enumMixinStr___struct_FILE_defined); 1774 } 1775 } 1776 static if (!is(typeof(_IO_EOF_SEEN))) 1777 { 1778 private enum enumMixinStr__IO_EOF_SEEN = `enum _IO_EOF_SEEN = 0x0010;`; 1779 static if (is(typeof({ mixin(enumMixinStr__IO_EOF_SEEN); }))) 1780 { 1781 mixin(enumMixinStr__IO_EOF_SEEN); 1782 } 1783 } 1784 1785 static if (!is(typeof(_IO_ERR_SEEN))) 1786 { 1787 private enum enumMixinStr__IO_ERR_SEEN = `enum _IO_ERR_SEEN = 0x0020;`; 1788 static if (is(typeof({ mixin(enumMixinStr__IO_ERR_SEEN); }))) 1789 { 1790 mixin(enumMixinStr__IO_ERR_SEEN); 1791 } 1792 } 1793 1794 static if (!is(typeof(_IO_USER_LOCK))) 1795 { 1796 private enum enumMixinStr__IO_USER_LOCK = `enum _IO_USER_LOCK = 0x8000;`; 1797 static if (is(typeof({ mixin(enumMixinStr__IO_USER_LOCK); }))) 1798 { 1799 mixin(enumMixinStr__IO_USER_LOCK); 1800 } 1801 } 1802 1803 static if (!is(typeof(__itimerspec_defined))) 1804 { 1805 private enum enumMixinStr___itimerspec_defined = `enum __itimerspec_defined = 1;`; 1806 static if (is(typeof({ mixin(enumMixinStr___itimerspec_defined); }))) 1807 { 1808 mixin(enumMixinStr___itimerspec_defined); 1809 } 1810 } 1811 static if (!is(typeof(WINT_MAX))) 1812 { 1813 private enum enumMixinStr_WINT_MAX = `enum WINT_MAX = ( 4294967295u );`; 1814 static if (is(typeof({ mixin(enumMixinStr_WINT_MAX); }))) 1815 { 1816 mixin(enumMixinStr_WINT_MAX); 1817 } 1818 } 1819 1820 static if (!is(typeof(_STRUCT_TIMESPEC))) 1821 { 1822 private enum enumMixinStr__STRUCT_TIMESPEC = `enum _STRUCT_TIMESPEC = 1;`; 1823 static if (is(typeof({ mixin(enumMixinStr__STRUCT_TIMESPEC); }))) 1824 { 1825 mixin(enumMixinStr__STRUCT_TIMESPEC); 1826 } 1827 } 1828 1829 static if (!is(typeof(WINT_MIN))) 1830 { 1831 private enum enumMixinStr_WINT_MIN = `enum WINT_MIN = ( 0u );`; 1832 static if (is(typeof({ mixin(enumMixinStr_WINT_MIN); }))) 1833 { 1834 mixin(enumMixinStr_WINT_MIN); 1835 } 1836 } 1837 1838 static if (!is(typeof(WCHAR_MAX))) 1839 { 1840 private enum enumMixinStr_WCHAR_MAX = `enum WCHAR_MAX = __WCHAR_MAX;`; 1841 static if (is(typeof({ mixin(enumMixinStr_WCHAR_MAX); }))) 1842 { 1843 mixin(enumMixinStr_WCHAR_MAX); 1844 } 1845 } 1846 1847 static if (!is(typeof(WCHAR_MIN))) 1848 { 1849 private enum enumMixinStr_WCHAR_MIN = `enum WCHAR_MIN = __WCHAR_MIN;`; 1850 static if (is(typeof({ mixin(enumMixinStr_WCHAR_MIN); }))) 1851 { 1852 mixin(enumMixinStr_WCHAR_MIN); 1853 } 1854 } 1855 1856 static if (!is(typeof(SIZE_MAX))) 1857 { 1858 private enum enumMixinStr_SIZE_MAX = `enum SIZE_MAX = ( 18446744073709551615UL );`; 1859 static if (is(typeof({ mixin(enumMixinStr_SIZE_MAX); }))) 1860 { 1861 mixin(enumMixinStr_SIZE_MAX); 1862 } 1863 } 1864 1865 static if (!is(typeof(SIG_ATOMIC_MAX))) 1866 { 1867 private enum enumMixinStr_SIG_ATOMIC_MAX = `enum SIG_ATOMIC_MAX = ( 2147483647 );`; 1868 static if (is(typeof({ mixin(enumMixinStr_SIG_ATOMIC_MAX); }))) 1869 { 1870 mixin(enumMixinStr_SIG_ATOMIC_MAX); 1871 } 1872 } 1873 1874 static if (!is(typeof(SIG_ATOMIC_MIN))) 1875 { 1876 private enum enumMixinStr_SIG_ATOMIC_MIN = `enum SIG_ATOMIC_MIN = ( - 2147483647 - 1 );`; 1877 static if (is(typeof({ mixin(enumMixinStr_SIG_ATOMIC_MIN); }))) 1878 { 1879 mixin(enumMixinStr_SIG_ATOMIC_MIN); 1880 } 1881 } 1882 1883 static if (!is(typeof(PTRDIFF_MAX))) 1884 { 1885 private enum enumMixinStr_PTRDIFF_MAX = `enum PTRDIFF_MAX = ( 9223372036854775807L );`; 1886 static if (is(typeof({ mixin(enumMixinStr_PTRDIFF_MAX); }))) 1887 { 1888 mixin(enumMixinStr_PTRDIFF_MAX); 1889 } 1890 } 1891 1892 static if (!is(typeof(__timeval_defined))) 1893 { 1894 private enum enumMixinStr___timeval_defined = `enum __timeval_defined = 1;`; 1895 static if (is(typeof({ mixin(enumMixinStr___timeval_defined); }))) 1896 { 1897 mixin(enumMixinStr___timeval_defined); 1898 } 1899 } 1900 1901 static if (!is(typeof(PTRDIFF_MIN))) 1902 { 1903 private enum enumMixinStr_PTRDIFF_MIN = `enum PTRDIFF_MIN = ( - 9223372036854775807L - 1 );`; 1904 static if (is(typeof({ mixin(enumMixinStr_PTRDIFF_MIN); }))) 1905 { 1906 mixin(enumMixinStr_PTRDIFF_MIN); 1907 } 1908 } 1909 1910 static if (!is(typeof(UINTMAX_MAX))) 1911 { 1912 private enum enumMixinStr_UINTMAX_MAX = `enum UINTMAX_MAX = ( 18446744073709551615UL );`; 1913 static if (is(typeof({ mixin(enumMixinStr_UINTMAX_MAX); }))) 1914 { 1915 mixin(enumMixinStr_UINTMAX_MAX); 1916 } 1917 } 1918 1919 static if (!is(typeof(__struct_tm_defined))) 1920 { 1921 private enum enumMixinStr___struct_tm_defined = `enum __struct_tm_defined = 1;`; 1922 static if (is(typeof({ mixin(enumMixinStr___struct_tm_defined); }))) 1923 { 1924 mixin(enumMixinStr___struct_tm_defined); 1925 } 1926 } 1927 1928 static if (!is(typeof(INTMAX_MAX))) 1929 { 1930 private enum enumMixinStr_INTMAX_MAX = `enum INTMAX_MAX = ( 9223372036854775807L );`; 1931 static if (is(typeof({ mixin(enumMixinStr_INTMAX_MAX); }))) 1932 { 1933 mixin(enumMixinStr_INTMAX_MAX); 1934 } 1935 } 1936 1937 static if (!is(typeof(INTMAX_MIN))) 1938 { 1939 private enum enumMixinStr_INTMAX_MIN = `enum INTMAX_MIN = ( - 9223372036854775807L - 1 );`; 1940 static if (is(typeof({ mixin(enumMixinStr_INTMAX_MIN); }))) 1941 { 1942 mixin(enumMixinStr_INTMAX_MIN); 1943 } 1944 } 1945 1946 static if (!is(typeof(UINTPTR_MAX))) 1947 { 1948 private enum enumMixinStr_UINTPTR_MAX = `enum UINTPTR_MAX = ( 18446744073709551615UL );`; 1949 static if (is(typeof({ mixin(enumMixinStr_UINTPTR_MAX); }))) 1950 { 1951 mixin(enumMixinStr_UINTPTR_MAX); 1952 } 1953 } 1954 1955 static if (!is(typeof(__time_t_defined))) 1956 { 1957 private enum enumMixinStr___time_t_defined = `enum __time_t_defined = 1;`; 1958 static if (is(typeof({ mixin(enumMixinStr___time_t_defined); }))) 1959 { 1960 mixin(enumMixinStr___time_t_defined); 1961 } 1962 } 1963 1964 static if (!is(typeof(INTPTR_MAX))) 1965 { 1966 private enum enumMixinStr_INTPTR_MAX = `enum INTPTR_MAX = ( 9223372036854775807L );`; 1967 static if (is(typeof({ mixin(enumMixinStr_INTPTR_MAX); }))) 1968 { 1969 mixin(enumMixinStr_INTPTR_MAX); 1970 } 1971 } 1972 1973 static if (!is(typeof(INTPTR_MIN))) 1974 { 1975 private enum enumMixinStr_INTPTR_MIN = `enum INTPTR_MIN = ( - 9223372036854775807L - 1 );`; 1976 static if (is(typeof({ mixin(enumMixinStr_INTPTR_MIN); }))) 1977 { 1978 mixin(enumMixinStr_INTPTR_MIN); 1979 } 1980 } 1981 1982 static if (!is(typeof(__timer_t_defined))) 1983 { 1984 private enum enumMixinStr___timer_t_defined = `enum __timer_t_defined = 1;`; 1985 static if (is(typeof({ mixin(enumMixinStr___timer_t_defined); }))) 1986 { 1987 mixin(enumMixinStr___timer_t_defined); 1988 } 1989 } 1990 1991 static if (!is(typeof(UINT_FAST64_MAX))) 1992 { 1993 private enum enumMixinStr_UINT_FAST64_MAX = `enum UINT_FAST64_MAX = ( 18446744073709551615UL );`; 1994 static if (is(typeof({ mixin(enumMixinStr_UINT_FAST64_MAX); }))) 1995 { 1996 mixin(enumMixinStr_UINT_FAST64_MAX); 1997 } 1998 } 1999 2000 static if (!is(typeof(UINT_FAST32_MAX))) 2001 { 2002 private enum enumMixinStr_UINT_FAST32_MAX = `enum UINT_FAST32_MAX = ( 18446744073709551615UL );`; 2003 static if (is(typeof({ mixin(enumMixinStr_UINT_FAST32_MAX); }))) 2004 { 2005 mixin(enumMixinStr_UINT_FAST32_MAX); 2006 } 2007 } 2008 2009 static if (!is(typeof(UINT_FAST16_MAX))) 2010 { 2011 private enum enumMixinStr_UINT_FAST16_MAX = `enum UINT_FAST16_MAX = ( 18446744073709551615UL );`; 2012 static if (is(typeof({ mixin(enumMixinStr_UINT_FAST16_MAX); }))) 2013 { 2014 mixin(enumMixinStr_UINT_FAST16_MAX); 2015 } 2016 } 2017 2018 static if (!is(typeof(_BITS_TYPESIZES_H))) 2019 { 2020 private enum enumMixinStr__BITS_TYPESIZES_H = `enum _BITS_TYPESIZES_H = 1;`; 2021 static if (is(typeof({ mixin(enumMixinStr__BITS_TYPESIZES_H); }))) 2022 { 2023 mixin(enumMixinStr__BITS_TYPESIZES_H); 2024 } 2025 } 2026 2027 static if (!is(typeof(UINT_FAST8_MAX))) 2028 { 2029 private enum enumMixinStr_UINT_FAST8_MAX = `enum UINT_FAST8_MAX = ( 255 );`; 2030 static if (is(typeof({ mixin(enumMixinStr_UINT_FAST8_MAX); }))) 2031 { 2032 mixin(enumMixinStr_UINT_FAST8_MAX); 2033 } 2034 } 2035 2036 static if (!is(typeof(__SYSCALL_SLONG_TYPE))) 2037 { 2038 private enum enumMixinStr___SYSCALL_SLONG_TYPE = `enum __SYSCALL_SLONG_TYPE = long int;`; 2039 static if (is(typeof({ mixin(enumMixinStr___SYSCALL_SLONG_TYPE); }))) 2040 { 2041 mixin(enumMixinStr___SYSCALL_SLONG_TYPE); 2042 } 2043 } 2044 2045 static if (!is(typeof(__SYSCALL_ULONG_TYPE))) 2046 { 2047 private enum enumMixinStr___SYSCALL_ULONG_TYPE = `enum __SYSCALL_ULONG_TYPE = unsigned long int;`; 2048 static if (is(typeof({ mixin(enumMixinStr___SYSCALL_ULONG_TYPE); }))) 2049 { 2050 mixin(enumMixinStr___SYSCALL_ULONG_TYPE); 2051 } 2052 } 2053 2054 static if (!is(typeof(__DEV_T_TYPE))) 2055 { 2056 private enum enumMixinStr___DEV_T_TYPE = `enum __DEV_T_TYPE = unsigned long int;`; 2057 static if (is(typeof({ mixin(enumMixinStr___DEV_T_TYPE); }))) 2058 { 2059 mixin(enumMixinStr___DEV_T_TYPE); 2060 } 2061 } 2062 2063 static if (!is(typeof(__UID_T_TYPE))) 2064 { 2065 private enum enumMixinStr___UID_T_TYPE = `enum __UID_T_TYPE = unsigned int;`; 2066 static if (is(typeof({ mixin(enumMixinStr___UID_T_TYPE); }))) 2067 { 2068 mixin(enumMixinStr___UID_T_TYPE); 2069 } 2070 } 2071 2072 static if (!is(typeof(__GID_T_TYPE))) 2073 { 2074 private enum enumMixinStr___GID_T_TYPE = `enum __GID_T_TYPE = unsigned int;`; 2075 static if (is(typeof({ mixin(enumMixinStr___GID_T_TYPE); }))) 2076 { 2077 mixin(enumMixinStr___GID_T_TYPE); 2078 } 2079 } 2080 2081 static if (!is(typeof(__INO_T_TYPE))) 2082 { 2083 private enum enumMixinStr___INO_T_TYPE = `enum __INO_T_TYPE = unsigned long int;`; 2084 static if (is(typeof({ mixin(enumMixinStr___INO_T_TYPE); }))) 2085 { 2086 mixin(enumMixinStr___INO_T_TYPE); 2087 } 2088 } 2089 2090 static if (!is(typeof(__INO64_T_TYPE))) 2091 { 2092 private enum enumMixinStr___INO64_T_TYPE = `enum __INO64_T_TYPE = unsigned long int;`; 2093 static if (is(typeof({ mixin(enumMixinStr___INO64_T_TYPE); }))) 2094 { 2095 mixin(enumMixinStr___INO64_T_TYPE); 2096 } 2097 } 2098 2099 static if (!is(typeof(__MODE_T_TYPE))) 2100 { 2101 private enum enumMixinStr___MODE_T_TYPE = `enum __MODE_T_TYPE = unsigned int;`; 2102 static if (is(typeof({ mixin(enumMixinStr___MODE_T_TYPE); }))) 2103 { 2104 mixin(enumMixinStr___MODE_T_TYPE); 2105 } 2106 } 2107 2108 static if (!is(typeof(INT_FAST64_MAX))) 2109 { 2110 private enum enumMixinStr_INT_FAST64_MAX = `enum INT_FAST64_MAX = ( 9223372036854775807L );`; 2111 static if (is(typeof({ mixin(enumMixinStr_INT_FAST64_MAX); }))) 2112 { 2113 mixin(enumMixinStr_INT_FAST64_MAX); 2114 } 2115 } 2116 2117 static if (!is(typeof(__NLINK_T_TYPE))) 2118 { 2119 private enum enumMixinStr___NLINK_T_TYPE = `enum __NLINK_T_TYPE = unsigned long int;`; 2120 static if (is(typeof({ mixin(enumMixinStr___NLINK_T_TYPE); }))) 2121 { 2122 mixin(enumMixinStr___NLINK_T_TYPE); 2123 } 2124 } 2125 2126 static if (!is(typeof(__FSWORD_T_TYPE))) 2127 { 2128 private enum enumMixinStr___FSWORD_T_TYPE = `enum __FSWORD_T_TYPE = long int;`; 2129 static if (is(typeof({ mixin(enumMixinStr___FSWORD_T_TYPE); }))) 2130 { 2131 mixin(enumMixinStr___FSWORD_T_TYPE); 2132 } 2133 } 2134 2135 static if (!is(typeof(__OFF_T_TYPE))) 2136 { 2137 private enum enumMixinStr___OFF_T_TYPE = `enum __OFF_T_TYPE = long int;`; 2138 static if (is(typeof({ mixin(enumMixinStr___OFF_T_TYPE); }))) 2139 { 2140 mixin(enumMixinStr___OFF_T_TYPE); 2141 } 2142 } 2143 2144 static if (!is(typeof(__OFF64_T_TYPE))) 2145 { 2146 private enum enumMixinStr___OFF64_T_TYPE = `enum __OFF64_T_TYPE = long int;`; 2147 static if (is(typeof({ mixin(enumMixinStr___OFF64_T_TYPE); }))) 2148 { 2149 mixin(enumMixinStr___OFF64_T_TYPE); 2150 } 2151 } 2152 2153 static if (!is(typeof(__PID_T_TYPE))) 2154 { 2155 private enum enumMixinStr___PID_T_TYPE = `enum __PID_T_TYPE = int;`; 2156 static if (is(typeof({ mixin(enumMixinStr___PID_T_TYPE); }))) 2157 { 2158 mixin(enumMixinStr___PID_T_TYPE); 2159 } 2160 } 2161 2162 static if (!is(typeof(__RLIM_T_TYPE))) 2163 { 2164 private enum enumMixinStr___RLIM_T_TYPE = `enum __RLIM_T_TYPE = unsigned long int;`; 2165 static if (is(typeof({ mixin(enumMixinStr___RLIM_T_TYPE); }))) 2166 { 2167 mixin(enumMixinStr___RLIM_T_TYPE); 2168 } 2169 } 2170 2171 static if (!is(typeof(__RLIM64_T_TYPE))) 2172 { 2173 private enum enumMixinStr___RLIM64_T_TYPE = `enum __RLIM64_T_TYPE = unsigned long int;`; 2174 static if (is(typeof({ mixin(enumMixinStr___RLIM64_T_TYPE); }))) 2175 { 2176 mixin(enumMixinStr___RLIM64_T_TYPE); 2177 } 2178 } 2179 2180 static if (!is(typeof(__BLKCNT_T_TYPE))) 2181 { 2182 private enum enumMixinStr___BLKCNT_T_TYPE = `enum __BLKCNT_T_TYPE = long int;`; 2183 static if (is(typeof({ mixin(enumMixinStr___BLKCNT_T_TYPE); }))) 2184 { 2185 mixin(enumMixinStr___BLKCNT_T_TYPE); 2186 } 2187 } 2188 2189 static if (!is(typeof(__BLKCNT64_T_TYPE))) 2190 { 2191 private enum enumMixinStr___BLKCNT64_T_TYPE = `enum __BLKCNT64_T_TYPE = long int;`; 2192 static if (is(typeof({ mixin(enumMixinStr___BLKCNT64_T_TYPE); }))) 2193 { 2194 mixin(enumMixinStr___BLKCNT64_T_TYPE); 2195 } 2196 } 2197 2198 static if (!is(typeof(__FSBLKCNT_T_TYPE))) 2199 { 2200 private enum enumMixinStr___FSBLKCNT_T_TYPE = `enum __FSBLKCNT_T_TYPE = unsigned long int;`; 2201 static if (is(typeof({ mixin(enumMixinStr___FSBLKCNT_T_TYPE); }))) 2202 { 2203 mixin(enumMixinStr___FSBLKCNT_T_TYPE); 2204 } 2205 } 2206 2207 static if (!is(typeof(__FSBLKCNT64_T_TYPE))) 2208 { 2209 private enum enumMixinStr___FSBLKCNT64_T_TYPE = `enum __FSBLKCNT64_T_TYPE = unsigned long int;`; 2210 static if (is(typeof({ mixin(enumMixinStr___FSBLKCNT64_T_TYPE); }))) 2211 { 2212 mixin(enumMixinStr___FSBLKCNT64_T_TYPE); 2213 } 2214 } 2215 2216 static if (!is(typeof(__FSFILCNT_T_TYPE))) 2217 { 2218 private enum enumMixinStr___FSFILCNT_T_TYPE = `enum __FSFILCNT_T_TYPE = unsigned long int;`; 2219 static if (is(typeof({ mixin(enumMixinStr___FSFILCNT_T_TYPE); }))) 2220 { 2221 mixin(enumMixinStr___FSFILCNT_T_TYPE); 2222 } 2223 } 2224 2225 static if (!is(typeof(__FSFILCNT64_T_TYPE))) 2226 { 2227 private enum enumMixinStr___FSFILCNT64_T_TYPE = `enum __FSFILCNT64_T_TYPE = unsigned long int;`; 2228 static if (is(typeof({ mixin(enumMixinStr___FSFILCNT64_T_TYPE); }))) 2229 { 2230 mixin(enumMixinStr___FSFILCNT64_T_TYPE); 2231 } 2232 } 2233 2234 static if (!is(typeof(__ID_T_TYPE))) 2235 { 2236 private enum enumMixinStr___ID_T_TYPE = `enum __ID_T_TYPE = unsigned int;`; 2237 static if (is(typeof({ mixin(enumMixinStr___ID_T_TYPE); }))) 2238 { 2239 mixin(enumMixinStr___ID_T_TYPE); 2240 } 2241 } 2242 2243 static if (!is(typeof(__CLOCK_T_TYPE))) 2244 { 2245 private enum enumMixinStr___CLOCK_T_TYPE = `enum __CLOCK_T_TYPE = long int;`; 2246 static if (is(typeof({ mixin(enumMixinStr___CLOCK_T_TYPE); }))) 2247 { 2248 mixin(enumMixinStr___CLOCK_T_TYPE); 2249 } 2250 } 2251 2252 static if (!is(typeof(__TIME_T_TYPE))) 2253 { 2254 private enum enumMixinStr___TIME_T_TYPE = `enum __TIME_T_TYPE = long int;`; 2255 static if (is(typeof({ mixin(enumMixinStr___TIME_T_TYPE); }))) 2256 { 2257 mixin(enumMixinStr___TIME_T_TYPE); 2258 } 2259 } 2260 2261 static if (!is(typeof(__USECONDS_T_TYPE))) 2262 { 2263 private enum enumMixinStr___USECONDS_T_TYPE = `enum __USECONDS_T_TYPE = unsigned int;`; 2264 static if (is(typeof({ mixin(enumMixinStr___USECONDS_T_TYPE); }))) 2265 { 2266 mixin(enumMixinStr___USECONDS_T_TYPE); 2267 } 2268 } 2269 2270 static if (!is(typeof(__SUSECONDS_T_TYPE))) 2271 { 2272 private enum enumMixinStr___SUSECONDS_T_TYPE = `enum __SUSECONDS_T_TYPE = long int;`; 2273 static if (is(typeof({ mixin(enumMixinStr___SUSECONDS_T_TYPE); }))) 2274 { 2275 mixin(enumMixinStr___SUSECONDS_T_TYPE); 2276 } 2277 } 2278 2279 static if (!is(typeof(__DADDR_T_TYPE))) 2280 { 2281 private enum enumMixinStr___DADDR_T_TYPE = `enum __DADDR_T_TYPE = int;`; 2282 static if (is(typeof({ mixin(enumMixinStr___DADDR_T_TYPE); }))) 2283 { 2284 mixin(enumMixinStr___DADDR_T_TYPE); 2285 } 2286 } 2287 2288 static if (!is(typeof(__KEY_T_TYPE))) 2289 { 2290 private enum enumMixinStr___KEY_T_TYPE = `enum __KEY_T_TYPE = int;`; 2291 static if (is(typeof({ mixin(enumMixinStr___KEY_T_TYPE); }))) 2292 { 2293 mixin(enumMixinStr___KEY_T_TYPE); 2294 } 2295 } 2296 2297 static if (!is(typeof(__CLOCKID_T_TYPE))) 2298 { 2299 private enum enumMixinStr___CLOCKID_T_TYPE = `enum __CLOCKID_T_TYPE = int;`; 2300 static if (is(typeof({ mixin(enumMixinStr___CLOCKID_T_TYPE); }))) 2301 { 2302 mixin(enumMixinStr___CLOCKID_T_TYPE); 2303 } 2304 } 2305 2306 static if (!is(typeof(__TIMER_T_TYPE))) 2307 { 2308 private enum enumMixinStr___TIMER_T_TYPE = `enum __TIMER_T_TYPE = void *;`; 2309 static if (is(typeof({ mixin(enumMixinStr___TIMER_T_TYPE); }))) 2310 { 2311 mixin(enumMixinStr___TIMER_T_TYPE); 2312 } 2313 } 2314 2315 static if (!is(typeof(__BLKSIZE_T_TYPE))) 2316 { 2317 private enum enumMixinStr___BLKSIZE_T_TYPE = `enum __BLKSIZE_T_TYPE = long int;`; 2318 static if (is(typeof({ mixin(enumMixinStr___BLKSIZE_T_TYPE); }))) 2319 { 2320 mixin(enumMixinStr___BLKSIZE_T_TYPE); 2321 } 2322 } 2323 2324 static if (!is(typeof(__FSID_T_TYPE))) 2325 { 2326 private enum enumMixinStr___FSID_T_TYPE = `enum __FSID_T_TYPE = { int __val [ 2 ] ; };`; 2327 static if (is(typeof({ mixin(enumMixinStr___FSID_T_TYPE); }))) 2328 { 2329 mixin(enumMixinStr___FSID_T_TYPE); 2330 } 2331 } 2332 2333 static if (!is(typeof(__SSIZE_T_TYPE))) 2334 { 2335 private enum enumMixinStr___SSIZE_T_TYPE = `enum __SSIZE_T_TYPE = long int;`; 2336 static if (is(typeof({ mixin(enumMixinStr___SSIZE_T_TYPE); }))) 2337 { 2338 mixin(enumMixinStr___SSIZE_T_TYPE); 2339 } 2340 } 2341 2342 static if (!is(typeof(__CPU_MASK_TYPE))) 2343 { 2344 private enum enumMixinStr___CPU_MASK_TYPE = `enum __CPU_MASK_TYPE = unsigned long int;`; 2345 static if (is(typeof({ mixin(enumMixinStr___CPU_MASK_TYPE); }))) 2346 { 2347 mixin(enumMixinStr___CPU_MASK_TYPE); 2348 } 2349 } 2350 2351 static if (!is(typeof(INT_FAST32_MAX))) 2352 { 2353 private enum enumMixinStr_INT_FAST32_MAX = `enum INT_FAST32_MAX = ( 9223372036854775807L );`; 2354 static if (is(typeof({ mixin(enumMixinStr_INT_FAST32_MAX); }))) 2355 { 2356 mixin(enumMixinStr_INT_FAST32_MAX); 2357 } 2358 } 2359 2360 static if (!is(typeof(__OFF_T_MATCHES_OFF64_T))) 2361 { 2362 private enum enumMixinStr___OFF_T_MATCHES_OFF64_T = `enum __OFF_T_MATCHES_OFF64_T = 1;`; 2363 static if (is(typeof({ mixin(enumMixinStr___OFF_T_MATCHES_OFF64_T); }))) 2364 { 2365 mixin(enumMixinStr___OFF_T_MATCHES_OFF64_T); 2366 } 2367 } 2368 2369 static if (!is(typeof(__INO_T_MATCHES_INO64_T))) 2370 { 2371 private enum enumMixinStr___INO_T_MATCHES_INO64_T = `enum __INO_T_MATCHES_INO64_T = 1;`; 2372 static if (is(typeof({ mixin(enumMixinStr___INO_T_MATCHES_INO64_T); }))) 2373 { 2374 mixin(enumMixinStr___INO_T_MATCHES_INO64_T); 2375 } 2376 } 2377 2378 static if (!is(typeof(__RLIM_T_MATCHES_RLIM64_T))) 2379 { 2380 private enum enumMixinStr___RLIM_T_MATCHES_RLIM64_T = `enum __RLIM_T_MATCHES_RLIM64_T = 1;`; 2381 static if (is(typeof({ mixin(enumMixinStr___RLIM_T_MATCHES_RLIM64_T); }))) 2382 { 2383 mixin(enumMixinStr___RLIM_T_MATCHES_RLIM64_T); 2384 } 2385 } 2386 2387 static if (!is(typeof(__STATFS_MATCHES_STATFS64))) 2388 { 2389 private enum enumMixinStr___STATFS_MATCHES_STATFS64 = `enum __STATFS_MATCHES_STATFS64 = 1;`; 2390 static if (is(typeof({ mixin(enumMixinStr___STATFS_MATCHES_STATFS64); }))) 2391 { 2392 mixin(enumMixinStr___STATFS_MATCHES_STATFS64); 2393 } 2394 } 2395 2396 static if (!is(typeof(__FD_SETSIZE))) 2397 { 2398 private enum enumMixinStr___FD_SETSIZE = `enum __FD_SETSIZE = 1024;`; 2399 static if (is(typeof({ mixin(enumMixinStr___FD_SETSIZE); }))) 2400 { 2401 mixin(enumMixinStr___FD_SETSIZE); 2402 } 2403 } 2404 2405 static if (!is(typeof(INT_FAST16_MAX))) 2406 { 2407 private enum enumMixinStr_INT_FAST16_MAX = `enum INT_FAST16_MAX = ( 9223372036854775807L );`; 2408 static if (is(typeof({ mixin(enumMixinStr_INT_FAST16_MAX); }))) 2409 { 2410 mixin(enumMixinStr_INT_FAST16_MAX); 2411 } 2412 } 2413 2414 static if (!is(typeof(_BITS_UINTN_IDENTITY_H))) 2415 { 2416 private enum enumMixinStr__BITS_UINTN_IDENTITY_H = `enum _BITS_UINTN_IDENTITY_H = 1;`; 2417 static if (is(typeof({ mixin(enumMixinStr__BITS_UINTN_IDENTITY_H); }))) 2418 { 2419 mixin(enumMixinStr__BITS_UINTN_IDENTITY_H); 2420 } 2421 } 2422 2423 static if (!is(typeof(INT_FAST8_MAX))) 2424 { 2425 private enum enumMixinStr_INT_FAST8_MAX = `enum INT_FAST8_MAX = ( 127 );`; 2426 static if (is(typeof({ mixin(enumMixinStr_INT_FAST8_MAX); }))) 2427 { 2428 mixin(enumMixinStr_INT_FAST8_MAX); 2429 } 2430 } 2431 2432 static if (!is(typeof(INT_FAST64_MIN))) 2433 { 2434 private enum enumMixinStr_INT_FAST64_MIN = `enum INT_FAST64_MIN = ( - 9223372036854775807L - 1 );`; 2435 static if (is(typeof({ mixin(enumMixinStr_INT_FAST64_MIN); }))) 2436 { 2437 mixin(enumMixinStr_INT_FAST64_MIN); 2438 } 2439 } 2440 2441 static if (!is(typeof(INT_FAST32_MIN))) 2442 { 2443 private enum enumMixinStr_INT_FAST32_MIN = `enum INT_FAST32_MIN = ( - 9223372036854775807L - 1 );`; 2444 static if (is(typeof({ mixin(enumMixinStr_INT_FAST32_MIN); }))) 2445 { 2446 mixin(enumMixinStr_INT_FAST32_MIN); 2447 } 2448 } 2449 2450 static if (!is(typeof(INT_FAST16_MIN))) 2451 { 2452 private enum enumMixinStr_INT_FAST16_MIN = `enum INT_FAST16_MIN = ( - 9223372036854775807L - 1 );`; 2453 static if (is(typeof({ mixin(enumMixinStr_INT_FAST16_MIN); }))) 2454 { 2455 mixin(enumMixinStr_INT_FAST16_MIN); 2456 } 2457 } 2458 2459 static if (!is(typeof(_BITS_WCHAR_H))) 2460 { 2461 private enum enumMixinStr__BITS_WCHAR_H = `enum _BITS_WCHAR_H = 1;`; 2462 static if (is(typeof({ mixin(enumMixinStr__BITS_WCHAR_H); }))) 2463 { 2464 mixin(enumMixinStr__BITS_WCHAR_H); 2465 } 2466 } 2467 2468 static if (!is(typeof(INT_FAST8_MIN))) 2469 { 2470 private enum enumMixinStr_INT_FAST8_MIN = `enum INT_FAST8_MIN = ( - 128 );`; 2471 static if (is(typeof({ mixin(enumMixinStr_INT_FAST8_MIN); }))) 2472 { 2473 mixin(enumMixinStr_INT_FAST8_MIN); 2474 } 2475 } 2476 2477 static if (!is(typeof(__WCHAR_MAX))) 2478 { 2479 private enum enumMixinStr___WCHAR_MAX = `enum __WCHAR_MAX = 0x7fffffff;`; 2480 static if (is(typeof({ mixin(enumMixinStr___WCHAR_MAX); }))) 2481 { 2482 mixin(enumMixinStr___WCHAR_MAX); 2483 } 2484 } 2485 2486 static if (!is(typeof(__WCHAR_MIN))) 2487 { 2488 private enum enumMixinStr___WCHAR_MIN = `enum __WCHAR_MIN = ( - 0x7fffffff - 1 );`; 2489 static if (is(typeof({ mixin(enumMixinStr___WCHAR_MIN); }))) 2490 { 2491 mixin(enumMixinStr___WCHAR_MIN); 2492 } 2493 } 2494 2495 static if (!is(typeof(UINT_LEAST64_MAX))) 2496 { 2497 private enum enumMixinStr_UINT_LEAST64_MAX = `enum UINT_LEAST64_MAX = ( 18446744073709551615UL );`; 2498 static if (is(typeof({ mixin(enumMixinStr_UINT_LEAST64_MAX); }))) 2499 { 2500 mixin(enumMixinStr_UINT_LEAST64_MAX); 2501 } 2502 } 2503 2504 static if (!is(typeof(UINT_LEAST32_MAX))) 2505 { 2506 private enum enumMixinStr_UINT_LEAST32_MAX = `enum UINT_LEAST32_MAX = ( 4294967295U );`; 2507 static if (is(typeof({ mixin(enumMixinStr_UINT_LEAST32_MAX); }))) 2508 { 2509 mixin(enumMixinStr_UINT_LEAST32_MAX); 2510 } 2511 } 2512 2513 static if (!is(typeof(UINT_LEAST16_MAX))) 2514 { 2515 private enum enumMixinStr_UINT_LEAST16_MAX = `enum UINT_LEAST16_MAX = ( 65535 );`; 2516 static if (is(typeof({ mixin(enumMixinStr_UINT_LEAST16_MAX); }))) 2517 { 2518 mixin(enumMixinStr_UINT_LEAST16_MAX); 2519 } 2520 } 2521 2522 static if (!is(typeof(UINT_LEAST8_MAX))) 2523 { 2524 private enum enumMixinStr_UINT_LEAST8_MAX = `enum UINT_LEAST8_MAX = ( 255 );`; 2525 static if (is(typeof({ mixin(enumMixinStr_UINT_LEAST8_MAX); }))) 2526 { 2527 mixin(enumMixinStr_UINT_LEAST8_MAX); 2528 } 2529 } 2530 2531 static if (!is(typeof(INT_LEAST64_MAX))) 2532 { 2533 private enum enumMixinStr_INT_LEAST64_MAX = `enum INT_LEAST64_MAX = ( 9223372036854775807L );`; 2534 static if (is(typeof({ mixin(enumMixinStr_INT_LEAST64_MAX); }))) 2535 { 2536 mixin(enumMixinStr_INT_LEAST64_MAX); 2537 } 2538 } 2539 2540 static if (!is(typeof(__WORDSIZE))) 2541 { 2542 private enum enumMixinStr___WORDSIZE = `enum __WORDSIZE = 64;`; 2543 static if (is(typeof({ mixin(enumMixinStr___WORDSIZE); }))) 2544 { 2545 mixin(enumMixinStr___WORDSIZE); 2546 } 2547 } 2548 2549 static if (!is(typeof(INT_LEAST32_MAX))) 2550 { 2551 private enum enumMixinStr_INT_LEAST32_MAX = `enum INT_LEAST32_MAX = ( 2147483647 );`; 2552 static if (is(typeof({ mixin(enumMixinStr_INT_LEAST32_MAX); }))) 2553 { 2554 mixin(enumMixinStr_INT_LEAST32_MAX); 2555 } 2556 } 2557 2558 static if (!is(typeof(INT_LEAST16_MAX))) 2559 { 2560 private enum enumMixinStr_INT_LEAST16_MAX = `enum INT_LEAST16_MAX = ( 32767 );`; 2561 static if (is(typeof({ mixin(enumMixinStr_INT_LEAST16_MAX); }))) 2562 { 2563 mixin(enumMixinStr_INT_LEAST16_MAX); 2564 } 2565 } 2566 2567 static if (!is(typeof(INT_LEAST8_MAX))) 2568 { 2569 private enum enumMixinStr_INT_LEAST8_MAX = `enum INT_LEAST8_MAX = ( 127 );`; 2570 static if (is(typeof({ mixin(enumMixinStr_INT_LEAST8_MAX); }))) 2571 { 2572 mixin(enumMixinStr_INT_LEAST8_MAX); 2573 } 2574 } 2575 2576 static if (!is(typeof(INT_LEAST64_MIN))) 2577 { 2578 private enum enumMixinStr_INT_LEAST64_MIN = `enum INT_LEAST64_MIN = ( - 9223372036854775807L - 1 );`; 2579 static if (is(typeof({ mixin(enumMixinStr_INT_LEAST64_MIN); }))) 2580 { 2581 mixin(enumMixinStr_INT_LEAST64_MIN); 2582 } 2583 } 2584 2585 static if (!is(typeof(INT_LEAST32_MIN))) 2586 { 2587 private enum enumMixinStr_INT_LEAST32_MIN = `enum INT_LEAST32_MIN = ( - 2147483647 - 1 );`; 2588 static if (is(typeof({ mixin(enumMixinStr_INT_LEAST32_MIN); }))) 2589 { 2590 mixin(enumMixinStr_INT_LEAST32_MIN); 2591 } 2592 } 2593 2594 static if (!is(typeof(__WORDSIZE_TIME64_COMPAT32))) 2595 { 2596 private enum enumMixinStr___WORDSIZE_TIME64_COMPAT32 = `enum __WORDSIZE_TIME64_COMPAT32 = 1;`; 2597 static if (is(typeof({ mixin(enumMixinStr___WORDSIZE_TIME64_COMPAT32); }))) 2598 { 2599 mixin(enumMixinStr___WORDSIZE_TIME64_COMPAT32); 2600 } 2601 } 2602 2603 static if (!is(typeof(__SYSCALL_WORDSIZE))) 2604 { 2605 private enum enumMixinStr___SYSCALL_WORDSIZE = `enum __SYSCALL_WORDSIZE = 64;`; 2606 static if (is(typeof({ mixin(enumMixinStr___SYSCALL_WORDSIZE); }))) 2607 { 2608 mixin(enumMixinStr___SYSCALL_WORDSIZE); 2609 } 2610 } 2611 static if (!is(typeof(INT_LEAST16_MIN))) 2612 { 2613 private enum enumMixinStr_INT_LEAST16_MIN = `enum INT_LEAST16_MIN = ( - 32767 - 1 );`; 2614 static if (is(typeof({ mixin(enumMixinStr_INT_LEAST16_MIN); }))) 2615 { 2616 mixin(enumMixinStr_INT_LEAST16_MIN); 2617 } 2618 } 2619 2620 static if (!is(typeof(INT_LEAST8_MIN))) 2621 { 2622 private enum enumMixinStr_INT_LEAST8_MIN = `enum INT_LEAST8_MIN = ( - 128 );`; 2623 static if (is(typeof({ mixin(enumMixinStr_INT_LEAST8_MIN); }))) 2624 { 2625 mixin(enumMixinStr_INT_LEAST8_MIN); 2626 } 2627 } 2628 2629 static if (!is(typeof(UINT64_MAX))) 2630 { 2631 private enum enumMixinStr_UINT64_MAX = `enum UINT64_MAX = ( 18446744073709551615UL );`; 2632 static if (is(typeof({ mixin(enumMixinStr_UINT64_MAX); }))) 2633 { 2634 mixin(enumMixinStr_UINT64_MAX); 2635 } 2636 } 2637 2638 static if (!is(typeof(UINT32_MAX))) 2639 { 2640 private enum enumMixinStr_UINT32_MAX = `enum UINT32_MAX = ( 4294967295U );`; 2641 static if (is(typeof({ mixin(enumMixinStr_UINT32_MAX); }))) 2642 { 2643 mixin(enumMixinStr_UINT32_MAX); 2644 } 2645 } 2646 2647 static if (!is(typeof(UINT16_MAX))) 2648 { 2649 private enum enumMixinStr_UINT16_MAX = `enum UINT16_MAX = ( 65535 );`; 2650 static if (is(typeof({ mixin(enumMixinStr_UINT16_MAX); }))) 2651 { 2652 mixin(enumMixinStr_UINT16_MAX); 2653 } 2654 } 2655 2656 static if (!is(typeof(_SYS_CDEFS_H))) 2657 { 2658 private enum enumMixinStr__SYS_CDEFS_H = `enum _SYS_CDEFS_H = 1;`; 2659 static if (is(typeof({ mixin(enumMixinStr__SYS_CDEFS_H); }))) 2660 { 2661 mixin(enumMixinStr__SYS_CDEFS_H); 2662 } 2663 } 2664 2665 static if (!is(typeof(UINT8_MAX))) 2666 { 2667 private enum enumMixinStr_UINT8_MAX = `enum UINT8_MAX = ( 255 );`; 2668 static if (is(typeof({ mixin(enumMixinStr_UINT8_MAX); }))) 2669 { 2670 mixin(enumMixinStr_UINT8_MAX); 2671 } 2672 } 2673 2674 static if (!is(typeof(INT64_MAX))) 2675 { 2676 private enum enumMixinStr_INT64_MAX = `enum INT64_MAX = ( 9223372036854775807L );`; 2677 static if (is(typeof({ mixin(enumMixinStr_INT64_MAX); }))) 2678 { 2679 mixin(enumMixinStr_INT64_MAX); 2680 } 2681 } 2682 2683 static if (!is(typeof(INT32_MAX))) 2684 { 2685 private enum enumMixinStr_INT32_MAX = `enum INT32_MAX = ( 2147483647 );`; 2686 static if (is(typeof({ mixin(enumMixinStr_INT32_MAX); }))) 2687 { 2688 mixin(enumMixinStr_INT32_MAX); 2689 } 2690 } 2691 2692 static if (!is(typeof(INT16_MAX))) 2693 { 2694 private enum enumMixinStr_INT16_MAX = `enum INT16_MAX = ( 32767 );`; 2695 static if (is(typeof({ mixin(enumMixinStr_INT16_MAX); }))) 2696 { 2697 mixin(enumMixinStr_INT16_MAX); 2698 } 2699 } 2700 2701 static if (!is(typeof(INT8_MAX))) 2702 { 2703 private enum enumMixinStr_INT8_MAX = `enum INT8_MAX = ( 127 );`; 2704 static if (is(typeof({ mixin(enumMixinStr_INT8_MAX); }))) 2705 { 2706 mixin(enumMixinStr_INT8_MAX); 2707 } 2708 } 2709 static if (!is(typeof(INT64_MIN))) 2710 { 2711 private enum enumMixinStr_INT64_MIN = `enum INT64_MIN = ( - 9223372036854775807L - 1 );`; 2712 static if (is(typeof({ mixin(enumMixinStr_INT64_MIN); }))) 2713 { 2714 mixin(enumMixinStr_INT64_MIN); 2715 } 2716 } 2717 2718 static if (!is(typeof(__THROW))) 2719 { 2720 private enum enumMixinStr___THROW = `enum __THROW = __attribute__ ( ( __nothrow__ ) );`; 2721 static if (is(typeof({ mixin(enumMixinStr___THROW); }))) 2722 { 2723 mixin(enumMixinStr___THROW); 2724 } 2725 } 2726 2727 static if (!is(typeof(__THROWNL))) 2728 { 2729 private enum enumMixinStr___THROWNL = `enum __THROWNL = __attribute__ ( ( __nothrow__ ) );`; 2730 static if (is(typeof({ mixin(enumMixinStr___THROWNL); }))) 2731 { 2732 mixin(enumMixinStr___THROWNL); 2733 } 2734 } 2735 static if (!is(typeof(INT32_MIN))) 2736 { 2737 private enum enumMixinStr_INT32_MIN = `enum INT32_MIN = ( - 2147483647 - 1 );`; 2738 static if (is(typeof({ mixin(enumMixinStr_INT32_MIN); }))) 2739 { 2740 mixin(enumMixinStr_INT32_MIN); 2741 } 2742 } 2743 2744 static if (!is(typeof(INT16_MIN))) 2745 { 2746 private enum enumMixinStr_INT16_MIN = `enum INT16_MIN = ( - 32767 - 1 );`; 2747 static if (is(typeof({ mixin(enumMixinStr_INT16_MIN); }))) 2748 { 2749 mixin(enumMixinStr_INT16_MIN); 2750 } 2751 } 2752 static if (!is(typeof(__ptr_t))) 2753 { 2754 private enum enumMixinStr___ptr_t = `enum __ptr_t = void *;`; 2755 static if (is(typeof({ mixin(enumMixinStr___ptr_t); }))) 2756 { 2757 mixin(enumMixinStr___ptr_t); 2758 } 2759 } 2760 static if (!is(typeof(INT8_MIN))) 2761 { 2762 private enum enumMixinStr_INT8_MIN = `enum INT8_MIN = ( - 128 );`; 2763 static if (is(typeof({ mixin(enumMixinStr_INT8_MIN); }))) 2764 { 2765 mixin(enumMixinStr_INT8_MIN); 2766 } 2767 } 2768 static if (!is(typeof(__flexarr))) 2769 { 2770 private enum enumMixinStr___flexarr = `enum __flexarr = [ ];`; 2771 static if (is(typeof({ mixin(enumMixinStr___flexarr); }))) 2772 { 2773 mixin(enumMixinStr___flexarr); 2774 } 2775 } 2776 2777 static if (!is(typeof(__glibc_c99_flexarr_available))) 2778 { 2779 private enum enumMixinStr___glibc_c99_flexarr_available = `enum __glibc_c99_flexarr_available = 1;`; 2780 static if (is(typeof({ 2781 mixin(enumMixinStr___glibc_c99_flexarr_available); 2782 }))) 2783 { 2784 mixin(enumMixinStr___glibc_c99_flexarr_available); 2785 } 2786 } 2787 static if (!is(typeof(_STDINT_H))) 2788 { 2789 private enum enumMixinStr__STDINT_H = `enum _STDINT_H = 1;`; 2790 static if (is(typeof({ mixin(enumMixinStr__STDINT_H); }))) 2791 { 2792 mixin(enumMixinStr__STDINT_H); 2793 } 2794 } 2795 2796 static if (!is(typeof(__attribute_malloc__))) 2797 { 2798 private enum enumMixinStr___attribute_malloc__ = `enum __attribute_malloc__ = __attribute__ ( ( __malloc__ ) );`; 2799 static if (is(typeof({ mixin(enumMixinStr___attribute_malloc__); }))) 2800 { 2801 mixin(enumMixinStr___attribute_malloc__); 2802 } 2803 } 2804 2805 static if (!is(typeof(_STDC_PREDEF_H))) 2806 { 2807 private enum enumMixinStr__STDC_PREDEF_H = `enum _STDC_PREDEF_H = 1;`; 2808 static if (is(typeof({ mixin(enumMixinStr__STDC_PREDEF_H); }))) 2809 { 2810 mixin(enumMixinStr__STDC_PREDEF_H); 2811 } 2812 } 2813 2814 static if (!is(typeof(__attribute_pure__))) 2815 { 2816 private enum enumMixinStr___attribute_pure__ = `enum __attribute_pure__ = __attribute__ ( ( __pure__ ) );`; 2817 static if (is(typeof({ mixin(enumMixinStr___attribute_pure__); }))) 2818 { 2819 mixin(enumMixinStr___attribute_pure__); 2820 } 2821 } 2822 2823 static if (!is(typeof(__attribute_const__))) 2824 { 2825 private enum enumMixinStr___attribute_const__ = `enum __attribute_const__ = __attribute__ ( cast( __const__ ) );`; 2826 static if (is(typeof({ mixin(enumMixinStr___attribute_const__); }))) 2827 { 2828 mixin(enumMixinStr___attribute_const__); 2829 } 2830 } 2831 2832 static if (!is(typeof(__GLIBC_MINOR__))) 2833 { 2834 private enum enumMixinStr___GLIBC_MINOR__ = `enum __GLIBC_MINOR__ = 31;`; 2835 static if (is(typeof({ mixin(enumMixinStr___GLIBC_MINOR__); }))) 2836 { 2837 mixin(enumMixinStr___GLIBC_MINOR__); 2838 } 2839 } 2840 2841 static if (!is(typeof(__attribute_used__))) 2842 { 2843 private enum enumMixinStr___attribute_used__ = `enum __attribute_used__ = __attribute__ ( ( __used__ ) );`; 2844 static if (is(typeof({ mixin(enumMixinStr___attribute_used__); }))) 2845 { 2846 mixin(enumMixinStr___attribute_used__); 2847 } 2848 } 2849 2850 static if (!is(typeof(__attribute_noinline__))) 2851 { 2852 private enum enumMixinStr___attribute_noinline__ = `enum __attribute_noinline__ = __attribute__ ( ( __noinline__ ) );`; 2853 static if (is(typeof({ mixin(enumMixinStr___attribute_noinline__); }))) 2854 { 2855 mixin(enumMixinStr___attribute_noinline__); 2856 } 2857 } 2858 2859 static if (!is(typeof(__GLIBC__))) 2860 { 2861 private enum enumMixinStr___GLIBC__ = `enum __GLIBC__ = 2;`; 2862 static if (is(typeof({ mixin(enumMixinStr___GLIBC__); }))) 2863 { 2864 mixin(enumMixinStr___GLIBC__); 2865 } 2866 } 2867 2868 static if (!is(typeof(__attribute_deprecated__))) 2869 { 2870 private enum enumMixinStr___attribute_deprecated__ = `enum __attribute_deprecated__ = __attribute__ ( ( __deprecated__ ) );`; 2871 static if (is(typeof({ mixin(enumMixinStr___attribute_deprecated__); }))) 2872 { 2873 mixin(enumMixinStr___attribute_deprecated__); 2874 } 2875 } 2876 2877 static if (!is(typeof(__GNU_LIBRARY__))) 2878 { 2879 private enum enumMixinStr___GNU_LIBRARY__ = `enum __GNU_LIBRARY__ = 6;`; 2880 static if (is(typeof({ mixin(enumMixinStr___GNU_LIBRARY__); }))) 2881 { 2882 mixin(enumMixinStr___GNU_LIBRARY__); 2883 } 2884 } 2885 2886 static if (!is(typeof(__GLIBC_USE_DEPRECATED_SCANF))) 2887 { 2888 private enum enumMixinStr___GLIBC_USE_DEPRECATED_SCANF = `enum __GLIBC_USE_DEPRECATED_SCANF = 0;`; 2889 static if (is(typeof({ mixin(enumMixinStr___GLIBC_USE_DEPRECATED_SCANF); }))) 2890 { 2891 mixin(enumMixinStr___GLIBC_USE_DEPRECATED_SCANF); 2892 } 2893 } 2894 2895 static if (!is(typeof(__GLIBC_USE_DEPRECATED_GETS))) 2896 { 2897 private enum enumMixinStr___GLIBC_USE_DEPRECATED_GETS = `enum __GLIBC_USE_DEPRECATED_GETS = 0;`; 2898 static if (is(typeof({ mixin(enumMixinStr___GLIBC_USE_DEPRECATED_GETS); }))) 2899 { 2900 mixin(enumMixinStr___GLIBC_USE_DEPRECATED_GETS); 2901 } 2902 } 2903 2904 static if (!is(typeof(__USE_FORTIFY_LEVEL))) 2905 { 2906 private enum enumMixinStr___USE_FORTIFY_LEVEL = `enum __USE_FORTIFY_LEVEL = 0;`; 2907 static if (is(typeof({ mixin(enumMixinStr___USE_FORTIFY_LEVEL); }))) 2908 { 2909 mixin(enumMixinStr___USE_FORTIFY_LEVEL); 2910 } 2911 } 2912 2913 static if (!is(typeof(__USE_ATFILE))) 2914 { 2915 private enum enumMixinStr___USE_ATFILE = `enum __USE_ATFILE = 1;`; 2916 static if (is(typeof({ mixin(enumMixinStr___USE_ATFILE); }))) 2917 { 2918 mixin(enumMixinStr___USE_ATFILE); 2919 } 2920 } 2921 2922 static if (!is(typeof(__USE_MISC))) 2923 { 2924 private enum enumMixinStr___USE_MISC = `enum __USE_MISC = 1;`; 2925 static if (is(typeof({ mixin(enumMixinStr___USE_MISC); }))) 2926 { 2927 mixin(enumMixinStr___USE_MISC); 2928 } 2929 } 2930 2931 static if (!is(typeof(__attribute_warn_unused_result__))) 2932 { 2933 private enum enumMixinStr___attribute_warn_unused_result__ = `enum __attribute_warn_unused_result__ = __attribute__ ( ( __warn_unused_result__ ) );`; 2934 static if (is(typeof({ 2935 mixin(enumMixinStr___attribute_warn_unused_result__); 2936 }))) 2937 { 2938 mixin(enumMixinStr___attribute_warn_unused_result__); 2939 } 2940 } 2941 2942 static if (!is(typeof(_ATFILE_SOURCE))) 2943 { 2944 private enum enumMixinStr__ATFILE_SOURCE = `enum _ATFILE_SOURCE = 1;`; 2945 static if (is(typeof({ mixin(enumMixinStr__ATFILE_SOURCE); }))) 2946 { 2947 mixin(enumMixinStr__ATFILE_SOURCE); 2948 } 2949 } 2950 2951 static if (!is(typeof(__USE_XOPEN2K8))) 2952 { 2953 private enum enumMixinStr___USE_XOPEN2K8 = `enum __USE_XOPEN2K8 = 1;`; 2954 static if (is(typeof({ mixin(enumMixinStr___USE_XOPEN2K8); }))) 2955 { 2956 mixin(enumMixinStr___USE_XOPEN2K8); 2957 } 2958 } 2959 2960 static if (!is(typeof(__always_inline))) 2961 { 2962 private enum enumMixinStr___always_inline = `enum __always_inline = __inline __attribute__ ( ( __always_inline__ ) );`; 2963 static if (is(typeof({ mixin(enumMixinStr___always_inline); }))) 2964 { 2965 mixin(enumMixinStr___always_inline); 2966 } 2967 } 2968 2969 static if (!is(typeof(__USE_ISOC99))) 2970 { 2971 private enum enumMixinStr___USE_ISOC99 = `enum __USE_ISOC99 = 1;`; 2972 static if (is(typeof({ mixin(enumMixinStr___USE_ISOC99); }))) 2973 { 2974 mixin(enumMixinStr___USE_ISOC99); 2975 } 2976 } 2977 2978 static if (!is(typeof(__USE_ISOC95))) 2979 { 2980 private enum enumMixinStr___USE_ISOC95 = `enum __USE_ISOC95 = 1;`; 2981 static if (is(typeof({ mixin(enumMixinStr___USE_ISOC95); }))) 2982 { 2983 mixin(enumMixinStr___USE_ISOC95); 2984 } 2985 } 2986 2987 static if (!is(typeof(__USE_XOPEN2K))) 2988 { 2989 private enum enumMixinStr___USE_XOPEN2K = `enum __USE_XOPEN2K = 1;`; 2990 static if (is(typeof({ mixin(enumMixinStr___USE_XOPEN2K); }))) 2991 { 2992 mixin(enumMixinStr___USE_XOPEN2K); 2993 } 2994 } 2995 2996 static if (!is(typeof(__USE_POSIX199506))) 2997 { 2998 private enum enumMixinStr___USE_POSIX199506 = `enum __USE_POSIX199506 = 1;`; 2999 static if (is(typeof({ mixin(enumMixinStr___USE_POSIX199506); }))) 3000 { 3001 mixin(enumMixinStr___USE_POSIX199506); 3002 } 3003 } 3004 3005 static if (!is(typeof(__USE_POSIX199309))) 3006 { 3007 private enum enumMixinStr___USE_POSIX199309 = `enum __USE_POSIX199309 = 1;`; 3008 static if (is(typeof({ mixin(enumMixinStr___USE_POSIX199309); }))) 3009 { 3010 mixin(enumMixinStr___USE_POSIX199309); 3011 } 3012 } 3013 3014 static if (!is(typeof(__extern_inline))) 3015 { 3016 private enum enumMixinStr___extern_inline = `enum __extern_inline = extern __inline __attribute__ ( ( __gnu_inline__ ) );`; 3017 static if (is(typeof({ mixin(enumMixinStr___extern_inline); }))) 3018 { 3019 mixin(enumMixinStr___extern_inline); 3020 } 3021 } 3022 3023 static if (!is(typeof(__extern_always_inline))) 3024 { 3025 private enum enumMixinStr___extern_always_inline = `enum __extern_always_inline = extern __inline __attribute__ ( ( __always_inline__ ) ) __attribute__ ( ( __gnu_inline__ ) );`; 3026 static if (is(typeof({ mixin(enumMixinStr___extern_always_inline); }))) 3027 { 3028 mixin(enumMixinStr___extern_always_inline); 3029 } 3030 } 3031 3032 static if (!is(typeof(__USE_POSIX2))) 3033 { 3034 private enum enumMixinStr___USE_POSIX2 = `enum __USE_POSIX2 = 1;`; 3035 static if (is(typeof({ mixin(enumMixinStr___USE_POSIX2); }))) 3036 { 3037 mixin(enumMixinStr___USE_POSIX2); 3038 } 3039 } 3040 3041 static if (!is(typeof(__fortify_function))) 3042 { 3043 private enum enumMixinStr___fortify_function = `enum __fortify_function = extern __inline __attribute__ ( ( __always_inline__ ) ) __attribute__ ( ( __gnu_inline__ ) ) ;`; 3044 static if (is(typeof({ mixin(enumMixinStr___fortify_function); }))) 3045 { 3046 mixin(enumMixinStr___fortify_function); 3047 } 3048 } 3049 3050 static if (!is(typeof(__USE_POSIX))) 3051 { 3052 private enum enumMixinStr___USE_POSIX = `enum __USE_POSIX = 1;`; 3053 static if (is(typeof({ mixin(enumMixinStr___USE_POSIX); }))) 3054 { 3055 mixin(enumMixinStr___USE_POSIX); 3056 } 3057 } 3058 3059 static if (!is(typeof(_POSIX_C_SOURCE))) 3060 { 3061 private enum enumMixinStr__POSIX_C_SOURCE = `enum _POSIX_C_SOURCE = 200809L;`; 3062 static if (is(typeof({ mixin(enumMixinStr__POSIX_C_SOURCE); }))) 3063 { 3064 mixin(enumMixinStr__POSIX_C_SOURCE); 3065 } 3066 } 3067 3068 static if (!is(typeof(_POSIX_SOURCE))) 3069 { 3070 private enum enumMixinStr__POSIX_SOURCE = `enum _POSIX_SOURCE = 1;`; 3071 static if (is(typeof({ mixin(enumMixinStr__POSIX_SOURCE); }))) 3072 { 3073 mixin(enumMixinStr__POSIX_SOURCE); 3074 } 3075 } 3076 3077 static if (!is(typeof(__USE_POSIX_IMPLICITLY))) 3078 { 3079 private enum enumMixinStr___USE_POSIX_IMPLICITLY = `enum __USE_POSIX_IMPLICITLY = 1;`; 3080 static if (is(typeof({ mixin(enumMixinStr___USE_POSIX_IMPLICITLY); }))) 3081 { 3082 mixin(enumMixinStr___USE_POSIX_IMPLICITLY); 3083 } 3084 } 3085 3086 static if (!is(typeof(__restrict_arr))) 3087 { 3088 private enum enumMixinStr___restrict_arr = `enum __restrict_arr = __restrict;`; 3089 static if (is(typeof({ mixin(enumMixinStr___restrict_arr); }))) 3090 { 3091 mixin(enumMixinStr___restrict_arr); 3092 } 3093 } 3094 static if (!is(typeof(__USE_ISOC11))) 3095 { 3096 private enum enumMixinStr___USE_ISOC11 = `enum __USE_ISOC11 = 1;`; 3097 static if (is(typeof({ mixin(enumMixinStr___USE_ISOC11); }))) 3098 { 3099 mixin(enumMixinStr___USE_ISOC11); 3100 } 3101 } 3102 3103 static if (!is(typeof(__GLIBC_USE_ISOC2X))) 3104 { 3105 private enum enumMixinStr___GLIBC_USE_ISOC2X = `enum __GLIBC_USE_ISOC2X = 0;`; 3106 static if (is(typeof({ mixin(enumMixinStr___GLIBC_USE_ISOC2X); }))) 3107 { 3108 mixin(enumMixinStr___GLIBC_USE_ISOC2X); 3109 } 3110 } 3111 3112 static if (!is(typeof(_DEFAULT_SOURCE))) 3113 { 3114 private enum enumMixinStr__DEFAULT_SOURCE = `enum _DEFAULT_SOURCE = 1;`; 3115 static if (is(typeof({ mixin(enumMixinStr__DEFAULT_SOURCE); }))) 3116 { 3117 mixin(enumMixinStr__DEFAULT_SOURCE); 3118 } 3119 } 3120 static if (!is(typeof(_FEATURES_H))) 3121 { 3122 private enum enumMixinStr__FEATURES_H = `enum _FEATURES_H = 1;`; 3123 static if (is(typeof({ mixin(enumMixinStr__FEATURES_H); }))) 3124 { 3125 mixin(enumMixinStr__FEATURES_H); 3126 } 3127 } 3128 static if (!is(typeof(__HAVE_GENERIC_SELECTION))) 3129 { 3130 private enum enumMixinStr___HAVE_GENERIC_SELECTION = `enum __HAVE_GENERIC_SELECTION = 1;`; 3131 static if (is(typeof({ mixin(enumMixinStr___HAVE_GENERIC_SELECTION); }))) 3132 { 3133 mixin(enumMixinStr___HAVE_GENERIC_SELECTION); 3134 } 3135 } 3136 3137 static if (!is(typeof(_SYS_SELECT_H))) 3138 { 3139 private enum enumMixinStr__SYS_SELECT_H = `enum _SYS_SELECT_H = 1;`; 3140 static if (is(typeof({ mixin(enumMixinStr__SYS_SELECT_H); }))) 3141 { 3142 mixin(enumMixinStr__SYS_SELECT_H); 3143 } 3144 } 3145 3146 static if (!is(typeof(BYTE_ORDER))) 3147 { 3148 private enum enumMixinStr_BYTE_ORDER = `enum BYTE_ORDER = 1234;`; 3149 static if (is(typeof({ mixin(enumMixinStr_BYTE_ORDER); }))) 3150 { 3151 mixin(enumMixinStr_BYTE_ORDER); 3152 } 3153 } 3154 3155 static if (!is(typeof(PDP_ENDIAN))) 3156 { 3157 private enum enumMixinStr_PDP_ENDIAN = `enum PDP_ENDIAN = 3412;`; 3158 static if (is(typeof({ mixin(enumMixinStr_PDP_ENDIAN); }))) 3159 { 3160 mixin(enumMixinStr_PDP_ENDIAN); 3161 } 3162 } 3163 3164 static if (!is(typeof(BIG_ENDIAN))) 3165 { 3166 private enum enumMixinStr_BIG_ENDIAN = `enum BIG_ENDIAN = 4321;`; 3167 static if (is(typeof({ mixin(enumMixinStr_BIG_ENDIAN); }))) 3168 { 3169 mixin(enumMixinStr_BIG_ENDIAN); 3170 } 3171 } 3172 3173 static if (!is(typeof(LITTLE_ENDIAN))) 3174 { 3175 private enum enumMixinStr_LITTLE_ENDIAN = `enum LITTLE_ENDIAN = 1234;`; 3176 static if (is(typeof({ mixin(enumMixinStr_LITTLE_ENDIAN); }))) 3177 { 3178 mixin(enumMixinStr_LITTLE_ENDIAN); 3179 } 3180 } 3181 3182 static if (!is(typeof(_ENDIAN_H))) 3183 { 3184 private enum enumMixinStr__ENDIAN_H = `enum _ENDIAN_H = 1;`; 3185 static if (is(typeof({ mixin(enumMixinStr__ENDIAN_H); }))) 3186 { 3187 mixin(enumMixinStr__ENDIAN_H); 3188 } 3189 } 3190 3191 static if (!is(typeof(__NFDBITS))) 3192 { 3193 private enum enumMixinStr___NFDBITS = `enum __NFDBITS = ( 8 * cast( int ) ( __fd_mask ) .sizeof );`; 3194 static if (is(typeof({ mixin(enumMixinStr___NFDBITS); }))) 3195 { 3196 mixin(enumMixinStr___NFDBITS); 3197 } 3198 } 3199 static if (!is(typeof(FD_SETSIZE))) 3200 { 3201 private enum enumMixinStr_FD_SETSIZE = `enum FD_SETSIZE = 1024;`; 3202 static if (is(typeof({ mixin(enumMixinStr_FD_SETSIZE); }))) 3203 { 3204 mixin(enumMixinStr_FD_SETSIZE); 3205 } 3206 } 3207 3208 static if (!is(typeof(NFDBITS))) 3209 { 3210 private enum enumMixinStr_NFDBITS = `enum NFDBITS = ( 8 * cast( int ) ( __fd_mask ) .sizeof );`; 3211 static if (is(typeof({ mixin(enumMixinStr_NFDBITS); }))) 3212 { 3213 mixin(enumMixinStr_NFDBITS); 3214 } 3215 } 3216 static if (!is(typeof(_SYS_TYPES_H))) 3217 { 3218 private enum enumMixinStr__SYS_TYPES_H = `enum _SYS_TYPES_H = 1;`; 3219 static if (is(typeof({ mixin(enumMixinStr__SYS_TYPES_H); }))) 3220 { 3221 mixin(enumMixinStr__SYS_TYPES_H); 3222 } 3223 } 3224 static if (!is(typeof(__BIT_TYPES_DEFINED__))) 3225 { 3226 private enum enumMixinStr___BIT_TYPES_DEFINED__ = `enum __BIT_TYPES_DEFINED__ = 1;`; 3227 static if (is(typeof({ mixin(enumMixinStr___BIT_TYPES_DEFINED__); }))) 3228 { 3229 mixin(enumMixinStr___BIT_TYPES_DEFINED__); 3230 } 3231 } 3232 static if (!is(typeof(ZIP_EXTERN))) 3233 { 3234 private enum enumMixinStr_ZIP_EXTERN = `enum ZIP_EXTERN = __attribute__ ( ( visibility ( "default" ) ) );`; 3235 static if (is(typeof({ mixin(enumMixinStr_ZIP_EXTERN); }))) 3236 { 3237 mixin(enumMixinStr_ZIP_EXTERN); 3238 } 3239 } 3240 3241 static if (!is(typeof(ZIP_CREATE))) 3242 { 3243 private enum enumMixinStr_ZIP_CREATE = `enum ZIP_CREATE = 1;`; 3244 static if (is(typeof({ mixin(enumMixinStr_ZIP_CREATE); }))) 3245 { 3246 mixin(enumMixinStr_ZIP_CREATE); 3247 } 3248 } 3249 3250 static if (!is(typeof(ZIP_EXCL))) 3251 { 3252 private enum enumMixinStr_ZIP_EXCL = `enum ZIP_EXCL = 2;`; 3253 static if (is(typeof({ mixin(enumMixinStr_ZIP_EXCL); }))) 3254 { 3255 mixin(enumMixinStr_ZIP_EXCL); 3256 } 3257 } 3258 3259 static if (!is(typeof(ZIP_CHECKCONS))) 3260 { 3261 private enum enumMixinStr_ZIP_CHECKCONS = `enum ZIP_CHECKCONS = 4;`; 3262 static if (is(typeof({ mixin(enumMixinStr_ZIP_CHECKCONS); }))) 3263 { 3264 mixin(enumMixinStr_ZIP_CHECKCONS); 3265 } 3266 } 3267 3268 static if (!is(typeof(ZIP_TRUNCATE))) 3269 { 3270 private enum enumMixinStr_ZIP_TRUNCATE = `enum ZIP_TRUNCATE = 8;`; 3271 static if (is(typeof({ mixin(enumMixinStr_ZIP_TRUNCATE); }))) 3272 { 3273 mixin(enumMixinStr_ZIP_TRUNCATE); 3274 } 3275 } 3276 3277 static if (!is(typeof(ZIP_RDONLY))) 3278 { 3279 private enum enumMixinStr_ZIP_RDONLY = `enum ZIP_RDONLY = 16;`; 3280 static if (is(typeof({ mixin(enumMixinStr_ZIP_RDONLY); }))) 3281 { 3282 mixin(enumMixinStr_ZIP_RDONLY); 3283 } 3284 } 3285 3286 static if (!is(typeof(ZIP_FL_NOCASE))) 3287 { 3288 private enum enumMixinStr_ZIP_FL_NOCASE = `enum ZIP_FL_NOCASE = 1u;`; 3289 static if (is(typeof({ mixin(enumMixinStr_ZIP_FL_NOCASE); }))) 3290 { 3291 mixin(enumMixinStr_ZIP_FL_NOCASE); 3292 } 3293 } 3294 3295 static if (!is(typeof(ZIP_FL_NODIR))) 3296 { 3297 private enum enumMixinStr_ZIP_FL_NODIR = `enum ZIP_FL_NODIR = 2u;`; 3298 static if (is(typeof({ mixin(enumMixinStr_ZIP_FL_NODIR); }))) 3299 { 3300 mixin(enumMixinStr_ZIP_FL_NODIR); 3301 } 3302 } 3303 3304 static if (!is(typeof(ZIP_FL_COMPRESSED))) 3305 { 3306 private enum enumMixinStr_ZIP_FL_COMPRESSED = `enum ZIP_FL_COMPRESSED = 4u;`; 3307 static if (is(typeof({ mixin(enumMixinStr_ZIP_FL_COMPRESSED); }))) 3308 { 3309 mixin(enumMixinStr_ZIP_FL_COMPRESSED); 3310 } 3311 } 3312 3313 static if (!is(typeof(ZIP_FL_UNCHANGED))) 3314 { 3315 private enum enumMixinStr_ZIP_FL_UNCHANGED = `enum ZIP_FL_UNCHANGED = 8u;`; 3316 static if (is(typeof({ mixin(enumMixinStr_ZIP_FL_UNCHANGED); }))) 3317 { 3318 mixin(enumMixinStr_ZIP_FL_UNCHANGED); 3319 } 3320 } 3321 3322 static if (!is(typeof(ZIP_FL_RECOMPRESS))) 3323 { 3324 private enum enumMixinStr_ZIP_FL_RECOMPRESS = `enum ZIP_FL_RECOMPRESS = 16u;`; 3325 static if (is(typeof({ mixin(enumMixinStr_ZIP_FL_RECOMPRESS); }))) 3326 { 3327 mixin(enumMixinStr_ZIP_FL_RECOMPRESS); 3328 } 3329 } 3330 3331 static if (!is(typeof(ZIP_FL_ENCRYPTED))) 3332 { 3333 private enum enumMixinStr_ZIP_FL_ENCRYPTED = `enum ZIP_FL_ENCRYPTED = 32u;`; 3334 static if (is(typeof({ mixin(enumMixinStr_ZIP_FL_ENCRYPTED); }))) 3335 { 3336 mixin(enumMixinStr_ZIP_FL_ENCRYPTED); 3337 } 3338 } 3339 3340 static if (!is(typeof(ZIP_FL_ENC_GUESS))) 3341 { 3342 private enum enumMixinStr_ZIP_FL_ENC_GUESS = `enum ZIP_FL_ENC_GUESS = 0u;`; 3343 static if (is(typeof({ mixin(enumMixinStr_ZIP_FL_ENC_GUESS); }))) 3344 { 3345 mixin(enumMixinStr_ZIP_FL_ENC_GUESS); 3346 } 3347 } 3348 3349 static if (!is(typeof(ZIP_FL_ENC_RAW))) 3350 { 3351 private enum enumMixinStr_ZIP_FL_ENC_RAW = `enum ZIP_FL_ENC_RAW = 64u;`; 3352 static if (is(typeof({ mixin(enumMixinStr_ZIP_FL_ENC_RAW); }))) 3353 { 3354 mixin(enumMixinStr_ZIP_FL_ENC_RAW); 3355 } 3356 } 3357 3358 static if (!is(typeof(ZIP_FL_ENC_STRICT))) 3359 { 3360 private enum enumMixinStr_ZIP_FL_ENC_STRICT = `enum ZIP_FL_ENC_STRICT = 128u;`; 3361 static if (is(typeof({ mixin(enumMixinStr_ZIP_FL_ENC_STRICT); }))) 3362 { 3363 mixin(enumMixinStr_ZIP_FL_ENC_STRICT); 3364 } 3365 } 3366 3367 static if (!is(typeof(ZIP_FL_LOCAL))) 3368 { 3369 private enum enumMixinStr_ZIP_FL_LOCAL = `enum ZIP_FL_LOCAL = 256u;`; 3370 static if (is(typeof({ mixin(enumMixinStr_ZIP_FL_LOCAL); }))) 3371 { 3372 mixin(enumMixinStr_ZIP_FL_LOCAL); 3373 } 3374 } 3375 3376 static if (!is(typeof(ZIP_FL_CENTRAL))) 3377 { 3378 private enum enumMixinStr_ZIP_FL_CENTRAL = `enum ZIP_FL_CENTRAL = 512u;`; 3379 static if (is(typeof({ mixin(enumMixinStr_ZIP_FL_CENTRAL); }))) 3380 { 3381 mixin(enumMixinStr_ZIP_FL_CENTRAL); 3382 } 3383 } 3384 3385 static if (!is(typeof(ZIP_FL_ENC_UTF_8))) 3386 { 3387 private enum enumMixinStr_ZIP_FL_ENC_UTF_8 = `enum ZIP_FL_ENC_UTF_8 = 2048u;`; 3388 static if (is(typeof({ mixin(enumMixinStr_ZIP_FL_ENC_UTF_8); }))) 3389 { 3390 mixin(enumMixinStr_ZIP_FL_ENC_UTF_8); 3391 } 3392 } 3393 3394 static if (!is(typeof(ZIP_FL_ENC_CP437))) 3395 { 3396 private enum enumMixinStr_ZIP_FL_ENC_CP437 = `enum ZIP_FL_ENC_CP437 = 4096u;`; 3397 static if (is(typeof({ mixin(enumMixinStr_ZIP_FL_ENC_CP437); }))) 3398 { 3399 mixin(enumMixinStr_ZIP_FL_ENC_CP437); 3400 } 3401 } 3402 3403 static if (!is(typeof(ZIP_FL_OVERWRITE))) 3404 { 3405 private enum enumMixinStr_ZIP_FL_OVERWRITE = `enum ZIP_FL_OVERWRITE = 8192u;`; 3406 static if (is(typeof({ mixin(enumMixinStr_ZIP_FL_OVERWRITE); }))) 3407 { 3408 mixin(enumMixinStr_ZIP_FL_OVERWRITE); 3409 } 3410 } 3411 3412 static if (!is(typeof(ZIP_AFL_RDONLY))) 3413 { 3414 private enum enumMixinStr_ZIP_AFL_RDONLY = `enum ZIP_AFL_RDONLY = 2u;`; 3415 static if (is(typeof({ mixin(enumMixinStr_ZIP_AFL_RDONLY); }))) 3416 { 3417 mixin(enumMixinStr_ZIP_AFL_RDONLY); 3418 } 3419 } 3420 3421 static if (!is(typeof(ZIP_EXTRA_FIELD_ALL))) 3422 { 3423 private enum enumMixinStr_ZIP_EXTRA_FIELD_ALL = `enum ZIP_EXTRA_FIELD_ALL = ZIP_UINT16_MAX;`; 3424 static if (is(typeof({ mixin(enumMixinStr_ZIP_EXTRA_FIELD_ALL); }))) 3425 { 3426 mixin(enumMixinStr_ZIP_EXTRA_FIELD_ALL); 3427 } 3428 } 3429 3430 static if (!is(typeof(ZIP_EXTRA_FIELD_NEW))) 3431 { 3432 private enum enumMixinStr_ZIP_EXTRA_FIELD_NEW = `enum ZIP_EXTRA_FIELD_NEW = ZIP_UINT16_MAX;`; 3433 static if (is(typeof({ mixin(enumMixinStr_ZIP_EXTRA_FIELD_NEW); }))) 3434 { 3435 mixin(enumMixinStr_ZIP_EXTRA_FIELD_NEW); 3436 } 3437 } 3438 3439 static if (!is(typeof(ZIP_ER_OK))) 3440 { 3441 private enum enumMixinStr_ZIP_ER_OK = `enum ZIP_ER_OK = 0;`; 3442 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_OK); }))) 3443 { 3444 mixin(enumMixinStr_ZIP_ER_OK); 3445 } 3446 } 3447 3448 static if (!is(typeof(ZIP_ER_MULTIDISK))) 3449 { 3450 private enum enumMixinStr_ZIP_ER_MULTIDISK = `enum ZIP_ER_MULTIDISK = 1;`; 3451 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_MULTIDISK); }))) 3452 { 3453 mixin(enumMixinStr_ZIP_ER_MULTIDISK); 3454 } 3455 } 3456 3457 static if (!is(typeof(ZIP_ER_RENAME))) 3458 { 3459 private enum enumMixinStr_ZIP_ER_RENAME = `enum ZIP_ER_RENAME = 2;`; 3460 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_RENAME); }))) 3461 { 3462 mixin(enumMixinStr_ZIP_ER_RENAME); 3463 } 3464 } 3465 3466 static if (!is(typeof(ZIP_ER_CLOSE))) 3467 { 3468 private enum enumMixinStr_ZIP_ER_CLOSE = `enum ZIP_ER_CLOSE = 3;`; 3469 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_CLOSE); }))) 3470 { 3471 mixin(enumMixinStr_ZIP_ER_CLOSE); 3472 } 3473 } 3474 3475 static if (!is(typeof(ZIP_ER_SEEK))) 3476 { 3477 private enum enumMixinStr_ZIP_ER_SEEK = `enum ZIP_ER_SEEK = 4;`; 3478 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_SEEK); }))) 3479 { 3480 mixin(enumMixinStr_ZIP_ER_SEEK); 3481 } 3482 } 3483 3484 static if (!is(typeof(ZIP_ER_READ))) 3485 { 3486 private enum enumMixinStr_ZIP_ER_READ = `enum ZIP_ER_READ = 5;`; 3487 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_READ); }))) 3488 { 3489 mixin(enumMixinStr_ZIP_ER_READ); 3490 } 3491 } 3492 3493 static if (!is(typeof(ZIP_ER_WRITE))) 3494 { 3495 private enum enumMixinStr_ZIP_ER_WRITE = `enum ZIP_ER_WRITE = 6;`; 3496 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_WRITE); }))) 3497 { 3498 mixin(enumMixinStr_ZIP_ER_WRITE); 3499 } 3500 } 3501 3502 static if (!is(typeof(ZIP_ER_CRC))) 3503 { 3504 private enum enumMixinStr_ZIP_ER_CRC = `enum ZIP_ER_CRC = 7;`; 3505 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_CRC); }))) 3506 { 3507 mixin(enumMixinStr_ZIP_ER_CRC); 3508 } 3509 } 3510 3511 static if (!is(typeof(ZIP_ER_ZIPCLOSED))) 3512 { 3513 private enum enumMixinStr_ZIP_ER_ZIPCLOSED = `enum ZIP_ER_ZIPCLOSED = 8;`; 3514 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_ZIPCLOSED); }))) 3515 { 3516 mixin(enumMixinStr_ZIP_ER_ZIPCLOSED); 3517 } 3518 } 3519 3520 static if (!is(typeof(ZIP_ER_NOENT))) 3521 { 3522 private enum enumMixinStr_ZIP_ER_NOENT = `enum ZIP_ER_NOENT = 9;`; 3523 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_NOENT); }))) 3524 { 3525 mixin(enumMixinStr_ZIP_ER_NOENT); 3526 } 3527 } 3528 3529 static if (!is(typeof(ZIP_ER_EXISTS))) 3530 { 3531 private enum enumMixinStr_ZIP_ER_EXISTS = `enum ZIP_ER_EXISTS = 10;`; 3532 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_EXISTS); }))) 3533 { 3534 mixin(enumMixinStr_ZIP_ER_EXISTS); 3535 } 3536 } 3537 3538 static if (!is(typeof(ZIP_ER_OPEN))) 3539 { 3540 private enum enumMixinStr_ZIP_ER_OPEN = `enum ZIP_ER_OPEN = 11;`; 3541 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_OPEN); }))) 3542 { 3543 mixin(enumMixinStr_ZIP_ER_OPEN); 3544 } 3545 } 3546 3547 static if (!is(typeof(ZIP_ER_TMPOPEN))) 3548 { 3549 private enum enumMixinStr_ZIP_ER_TMPOPEN = `enum ZIP_ER_TMPOPEN = 12;`; 3550 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_TMPOPEN); }))) 3551 { 3552 mixin(enumMixinStr_ZIP_ER_TMPOPEN); 3553 } 3554 } 3555 3556 static if (!is(typeof(ZIP_ER_ZLIB))) 3557 { 3558 private enum enumMixinStr_ZIP_ER_ZLIB = `enum ZIP_ER_ZLIB = 13;`; 3559 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_ZLIB); }))) 3560 { 3561 mixin(enumMixinStr_ZIP_ER_ZLIB); 3562 } 3563 } 3564 3565 static if (!is(typeof(ZIP_ER_MEMORY))) 3566 { 3567 private enum enumMixinStr_ZIP_ER_MEMORY = `enum ZIP_ER_MEMORY = 14;`; 3568 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_MEMORY); }))) 3569 { 3570 mixin(enumMixinStr_ZIP_ER_MEMORY); 3571 } 3572 } 3573 3574 static if (!is(typeof(ZIP_ER_CHANGED))) 3575 { 3576 private enum enumMixinStr_ZIP_ER_CHANGED = `enum ZIP_ER_CHANGED = 15;`; 3577 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_CHANGED); }))) 3578 { 3579 mixin(enumMixinStr_ZIP_ER_CHANGED); 3580 } 3581 } 3582 3583 static if (!is(typeof(ZIP_ER_COMPNOTSUPP))) 3584 { 3585 private enum enumMixinStr_ZIP_ER_COMPNOTSUPP = `enum ZIP_ER_COMPNOTSUPP = 16;`; 3586 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_COMPNOTSUPP); }))) 3587 { 3588 mixin(enumMixinStr_ZIP_ER_COMPNOTSUPP); 3589 } 3590 } 3591 3592 static if (!is(typeof(ZIP_ER_EOF))) 3593 { 3594 private enum enumMixinStr_ZIP_ER_EOF = `enum ZIP_ER_EOF = 17;`; 3595 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_EOF); }))) 3596 { 3597 mixin(enumMixinStr_ZIP_ER_EOF); 3598 } 3599 } 3600 3601 static if (!is(typeof(ZIP_ER_INVAL))) 3602 { 3603 private enum enumMixinStr_ZIP_ER_INVAL = `enum ZIP_ER_INVAL = 18;`; 3604 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_INVAL); }))) 3605 { 3606 mixin(enumMixinStr_ZIP_ER_INVAL); 3607 } 3608 } 3609 3610 static if (!is(typeof(ZIP_ER_NOZIP))) 3611 { 3612 private enum enumMixinStr_ZIP_ER_NOZIP = `enum ZIP_ER_NOZIP = 19;`; 3613 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_NOZIP); }))) 3614 { 3615 mixin(enumMixinStr_ZIP_ER_NOZIP); 3616 } 3617 } 3618 3619 static if (!is(typeof(ZIP_ER_INTERNAL))) 3620 { 3621 private enum enumMixinStr_ZIP_ER_INTERNAL = `enum ZIP_ER_INTERNAL = 20;`; 3622 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_INTERNAL); }))) 3623 { 3624 mixin(enumMixinStr_ZIP_ER_INTERNAL); 3625 } 3626 } 3627 3628 static if (!is(typeof(ZIP_ER_INCONS))) 3629 { 3630 private enum enumMixinStr_ZIP_ER_INCONS = `enum ZIP_ER_INCONS = 21;`; 3631 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_INCONS); }))) 3632 { 3633 mixin(enumMixinStr_ZIP_ER_INCONS); 3634 } 3635 } 3636 3637 static if (!is(typeof(ZIP_ER_REMOVE))) 3638 { 3639 private enum enumMixinStr_ZIP_ER_REMOVE = `enum ZIP_ER_REMOVE = 22;`; 3640 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_REMOVE); }))) 3641 { 3642 mixin(enumMixinStr_ZIP_ER_REMOVE); 3643 } 3644 } 3645 3646 static if (!is(typeof(ZIP_ER_DELETED))) 3647 { 3648 private enum enumMixinStr_ZIP_ER_DELETED = `enum ZIP_ER_DELETED = 23;`; 3649 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_DELETED); }))) 3650 { 3651 mixin(enumMixinStr_ZIP_ER_DELETED); 3652 } 3653 } 3654 3655 static if (!is(typeof(ZIP_ER_ENCRNOTSUPP))) 3656 { 3657 private enum enumMixinStr_ZIP_ER_ENCRNOTSUPP = `enum ZIP_ER_ENCRNOTSUPP = 24;`; 3658 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_ENCRNOTSUPP); }))) 3659 { 3660 mixin(enumMixinStr_ZIP_ER_ENCRNOTSUPP); 3661 } 3662 } 3663 3664 static if (!is(typeof(ZIP_ER_RDONLY))) 3665 { 3666 private enum enumMixinStr_ZIP_ER_RDONLY = `enum ZIP_ER_RDONLY = 25;`; 3667 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_RDONLY); }))) 3668 { 3669 mixin(enumMixinStr_ZIP_ER_RDONLY); 3670 } 3671 } 3672 3673 static if (!is(typeof(ZIP_ER_NOPASSWD))) 3674 { 3675 private enum enumMixinStr_ZIP_ER_NOPASSWD = `enum ZIP_ER_NOPASSWD = 26;`; 3676 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_NOPASSWD); }))) 3677 { 3678 mixin(enumMixinStr_ZIP_ER_NOPASSWD); 3679 } 3680 } 3681 3682 static if (!is(typeof(ZIP_ER_WRONGPASSWD))) 3683 { 3684 private enum enumMixinStr_ZIP_ER_WRONGPASSWD = `enum ZIP_ER_WRONGPASSWD = 27;`; 3685 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_WRONGPASSWD); }))) 3686 { 3687 mixin(enumMixinStr_ZIP_ER_WRONGPASSWD); 3688 } 3689 } 3690 3691 static if (!is(typeof(ZIP_ER_OPNOTSUPP))) 3692 { 3693 private enum enumMixinStr_ZIP_ER_OPNOTSUPP = `enum ZIP_ER_OPNOTSUPP = 28;`; 3694 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_OPNOTSUPP); }))) 3695 { 3696 mixin(enumMixinStr_ZIP_ER_OPNOTSUPP); 3697 } 3698 } 3699 3700 static if (!is(typeof(ZIP_ER_INUSE))) 3701 { 3702 private enum enumMixinStr_ZIP_ER_INUSE = `enum ZIP_ER_INUSE = 29;`; 3703 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_INUSE); }))) 3704 { 3705 mixin(enumMixinStr_ZIP_ER_INUSE); 3706 } 3707 } 3708 3709 static if (!is(typeof(ZIP_ER_TELL))) 3710 { 3711 private enum enumMixinStr_ZIP_ER_TELL = `enum ZIP_ER_TELL = 30;`; 3712 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_TELL); }))) 3713 { 3714 mixin(enumMixinStr_ZIP_ER_TELL); 3715 } 3716 } 3717 3718 static if (!is(typeof(ZIP_ER_COMPRESSED_DATA))) 3719 { 3720 private enum enumMixinStr_ZIP_ER_COMPRESSED_DATA = `enum ZIP_ER_COMPRESSED_DATA = 31;`; 3721 static if (is(typeof({ mixin(enumMixinStr_ZIP_ER_COMPRESSED_DATA); }))) 3722 { 3723 mixin(enumMixinStr_ZIP_ER_COMPRESSED_DATA); 3724 } 3725 } 3726 3727 static if (!is(typeof(ZIP_ET_NONE))) 3728 { 3729 private enum enumMixinStr_ZIP_ET_NONE = `enum ZIP_ET_NONE = 0;`; 3730 static if (is(typeof({ mixin(enumMixinStr_ZIP_ET_NONE); }))) 3731 { 3732 mixin(enumMixinStr_ZIP_ET_NONE); 3733 } 3734 } 3735 3736 static if (!is(typeof(ZIP_ET_SYS))) 3737 { 3738 private enum enumMixinStr_ZIP_ET_SYS = `enum ZIP_ET_SYS = 1;`; 3739 static if (is(typeof({ mixin(enumMixinStr_ZIP_ET_SYS); }))) 3740 { 3741 mixin(enumMixinStr_ZIP_ET_SYS); 3742 } 3743 } 3744 3745 static if (!is(typeof(ZIP_ET_ZLIB))) 3746 { 3747 private enum enumMixinStr_ZIP_ET_ZLIB = `enum ZIP_ET_ZLIB = 2;`; 3748 static if (is(typeof({ mixin(enumMixinStr_ZIP_ET_ZLIB); }))) 3749 { 3750 mixin(enumMixinStr_ZIP_ET_ZLIB); 3751 } 3752 } 3753 3754 static if (!is(typeof(ZIP_CM_DEFAULT))) 3755 { 3756 private enum enumMixinStr_ZIP_CM_DEFAULT = `enum ZIP_CM_DEFAULT = - 1;`; 3757 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_DEFAULT); }))) 3758 { 3759 mixin(enumMixinStr_ZIP_CM_DEFAULT); 3760 } 3761 } 3762 3763 static if (!is(typeof(ZIP_CM_STORE))) 3764 { 3765 private enum enumMixinStr_ZIP_CM_STORE = `enum ZIP_CM_STORE = 0;`; 3766 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_STORE); }))) 3767 { 3768 mixin(enumMixinStr_ZIP_CM_STORE); 3769 } 3770 } 3771 3772 static if (!is(typeof(ZIP_CM_SHRINK))) 3773 { 3774 private enum enumMixinStr_ZIP_CM_SHRINK = `enum ZIP_CM_SHRINK = 1;`; 3775 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_SHRINK); }))) 3776 { 3777 mixin(enumMixinStr_ZIP_CM_SHRINK); 3778 } 3779 } 3780 3781 static if (!is(typeof(ZIP_CM_REDUCE_1))) 3782 { 3783 private enum enumMixinStr_ZIP_CM_REDUCE_1 = `enum ZIP_CM_REDUCE_1 = 2;`; 3784 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_REDUCE_1); }))) 3785 { 3786 mixin(enumMixinStr_ZIP_CM_REDUCE_1); 3787 } 3788 } 3789 3790 static if (!is(typeof(ZIP_CM_REDUCE_2))) 3791 { 3792 private enum enumMixinStr_ZIP_CM_REDUCE_2 = `enum ZIP_CM_REDUCE_2 = 3;`; 3793 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_REDUCE_2); }))) 3794 { 3795 mixin(enumMixinStr_ZIP_CM_REDUCE_2); 3796 } 3797 } 3798 3799 static if (!is(typeof(ZIP_CM_REDUCE_3))) 3800 { 3801 private enum enumMixinStr_ZIP_CM_REDUCE_3 = `enum ZIP_CM_REDUCE_3 = 4;`; 3802 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_REDUCE_3); }))) 3803 { 3804 mixin(enumMixinStr_ZIP_CM_REDUCE_3); 3805 } 3806 } 3807 3808 static if (!is(typeof(ZIP_CM_REDUCE_4))) 3809 { 3810 private enum enumMixinStr_ZIP_CM_REDUCE_4 = `enum ZIP_CM_REDUCE_4 = 5;`; 3811 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_REDUCE_4); }))) 3812 { 3813 mixin(enumMixinStr_ZIP_CM_REDUCE_4); 3814 } 3815 } 3816 3817 static if (!is(typeof(ZIP_CM_IMPLODE))) 3818 { 3819 private enum enumMixinStr_ZIP_CM_IMPLODE = `enum ZIP_CM_IMPLODE = 6;`; 3820 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_IMPLODE); }))) 3821 { 3822 mixin(enumMixinStr_ZIP_CM_IMPLODE); 3823 } 3824 } 3825 3826 static if (!is(typeof(ZIP_CM_DEFLATE))) 3827 { 3828 private enum enumMixinStr_ZIP_CM_DEFLATE = `enum ZIP_CM_DEFLATE = 8;`; 3829 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_DEFLATE); }))) 3830 { 3831 mixin(enumMixinStr_ZIP_CM_DEFLATE); 3832 } 3833 } 3834 3835 static if (!is(typeof(ZIP_CM_DEFLATE64))) 3836 { 3837 private enum enumMixinStr_ZIP_CM_DEFLATE64 = `enum ZIP_CM_DEFLATE64 = 9;`; 3838 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_DEFLATE64); }))) 3839 { 3840 mixin(enumMixinStr_ZIP_CM_DEFLATE64); 3841 } 3842 } 3843 3844 static if (!is(typeof(ZIP_CM_PKWARE_IMPLODE))) 3845 { 3846 private enum enumMixinStr_ZIP_CM_PKWARE_IMPLODE = `enum ZIP_CM_PKWARE_IMPLODE = 10;`; 3847 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_PKWARE_IMPLODE); }))) 3848 { 3849 mixin(enumMixinStr_ZIP_CM_PKWARE_IMPLODE); 3850 } 3851 } 3852 3853 static if (!is(typeof(ZIP_CM_BZIP2))) 3854 { 3855 private enum enumMixinStr_ZIP_CM_BZIP2 = `enum ZIP_CM_BZIP2 = 12;`; 3856 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_BZIP2); }))) 3857 { 3858 mixin(enumMixinStr_ZIP_CM_BZIP2); 3859 } 3860 } 3861 3862 static if (!is(typeof(ZIP_CM_LZMA))) 3863 { 3864 private enum enumMixinStr_ZIP_CM_LZMA = `enum ZIP_CM_LZMA = 14;`; 3865 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_LZMA); }))) 3866 { 3867 mixin(enumMixinStr_ZIP_CM_LZMA); 3868 } 3869 } 3870 3871 static if (!is(typeof(ZIP_CM_TERSE))) 3872 { 3873 private enum enumMixinStr_ZIP_CM_TERSE = `enum ZIP_CM_TERSE = 18;`; 3874 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_TERSE); }))) 3875 { 3876 mixin(enumMixinStr_ZIP_CM_TERSE); 3877 } 3878 } 3879 3880 static if (!is(typeof(ZIP_CM_LZ77))) 3881 { 3882 private enum enumMixinStr_ZIP_CM_LZ77 = `enum ZIP_CM_LZ77 = 19;`; 3883 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_LZ77); }))) 3884 { 3885 mixin(enumMixinStr_ZIP_CM_LZ77); 3886 } 3887 } 3888 3889 static if (!is(typeof(ZIP_CM_XZ))) 3890 { 3891 private enum enumMixinStr_ZIP_CM_XZ = `enum ZIP_CM_XZ = 95;`; 3892 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_XZ); }))) 3893 { 3894 mixin(enumMixinStr_ZIP_CM_XZ); 3895 } 3896 } 3897 3898 static if (!is(typeof(ZIP_CM_JPEG))) 3899 { 3900 private enum enumMixinStr_ZIP_CM_JPEG = `enum ZIP_CM_JPEG = 96;`; 3901 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_JPEG); }))) 3902 { 3903 mixin(enumMixinStr_ZIP_CM_JPEG); 3904 } 3905 } 3906 3907 static if (!is(typeof(ZIP_CM_WAVPACK))) 3908 { 3909 private enum enumMixinStr_ZIP_CM_WAVPACK = `enum ZIP_CM_WAVPACK = 97;`; 3910 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_WAVPACK); }))) 3911 { 3912 mixin(enumMixinStr_ZIP_CM_WAVPACK); 3913 } 3914 } 3915 3916 static if (!is(typeof(ZIP_CM_PPMD))) 3917 { 3918 private enum enumMixinStr_ZIP_CM_PPMD = `enum ZIP_CM_PPMD = 98;`; 3919 static if (is(typeof({ mixin(enumMixinStr_ZIP_CM_PPMD); }))) 3920 { 3921 mixin(enumMixinStr_ZIP_CM_PPMD); 3922 } 3923 } 3924 3925 static if (!is(typeof(ZIP_EM_NONE))) 3926 { 3927 private enum enumMixinStr_ZIP_EM_NONE = `enum ZIP_EM_NONE = 0;`; 3928 static if (is(typeof({ mixin(enumMixinStr_ZIP_EM_NONE); }))) 3929 { 3930 mixin(enumMixinStr_ZIP_EM_NONE); 3931 } 3932 } 3933 3934 static if (!is(typeof(ZIP_EM_TRAD_PKWARE))) 3935 { 3936 private enum enumMixinStr_ZIP_EM_TRAD_PKWARE = `enum ZIP_EM_TRAD_PKWARE = 1;`; 3937 static if (is(typeof({ mixin(enumMixinStr_ZIP_EM_TRAD_PKWARE); }))) 3938 { 3939 mixin(enumMixinStr_ZIP_EM_TRAD_PKWARE); 3940 } 3941 } 3942 3943 static if (!is(typeof(ZIP_EM_AES_128))) 3944 { 3945 private enum enumMixinStr_ZIP_EM_AES_128 = `enum ZIP_EM_AES_128 = 0x0101;`; 3946 static if (is(typeof({ mixin(enumMixinStr_ZIP_EM_AES_128); }))) 3947 { 3948 mixin(enumMixinStr_ZIP_EM_AES_128); 3949 } 3950 } 3951 3952 static if (!is(typeof(ZIP_EM_AES_192))) 3953 { 3954 private enum enumMixinStr_ZIP_EM_AES_192 = `enum ZIP_EM_AES_192 = 0x0102;`; 3955 static if (is(typeof({ mixin(enumMixinStr_ZIP_EM_AES_192); }))) 3956 { 3957 mixin(enumMixinStr_ZIP_EM_AES_192); 3958 } 3959 } 3960 3961 static if (!is(typeof(ZIP_EM_AES_256))) 3962 { 3963 private enum enumMixinStr_ZIP_EM_AES_256 = `enum ZIP_EM_AES_256 = 0x0103;`; 3964 static if (is(typeof({ mixin(enumMixinStr_ZIP_EM_AES_256); }))) 3965 { 3966 mixin(enumMixinStr_ZIP_EM_AES_256); 3967 } 3968 } 3969 3970 static if (!is(typeof(ZIP_EM_UNKNOWN))) 3971 { 3972 private enum enumMixinStr_ZIP_EM_UNKNOWN = `enum ZIP_EM_UNKNOWN = 0xffff;`; 3973 static if (is(typeof({ mixin(enumMixinStr_ZIP_EM_UNKNOWN); }))) 3974 { 3975 mixin(enumMixinStr_ZIP_EM_UNKNOWN); 3976 } 3977 } 3978 3979 static if (!is(typeof(ZIP_OPSYS_DOS))) 3980 { 3981 private enum enumMixinStr_ZIP_OPSYS_DOS = `enum ZIP_OPSYS_DOS = 0x00u;`; 3982 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_DOS); }))) 3983 { 3984 mixin(enumMixinStr_ZIP_OPSYS_DOS); 3985 } 3986 } 3987 3988 static if (!is(typeof(ZIP_OPSYS_AMIGA))) 3989 { 3990 private enum enumMixinStr_ZIP_OPSYS_AMIGA = `enum ZIP_OPSYS_AMIGA = 0x01u;`; 3991 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_AMIGA); }))) 3992 { 3993 mixin(enumMixinStr_ZIP_OPSYS_AMIGA); 3994 } 3995 } 3996 3997 static if (!is(typeof(ZIP_OPSYS_OPENVMS))) 3998 { 3999 private enum enumMixinStr_ZIP_OPSYS_OPENVMS = `enum ZIP_OPSYS_OPENVMS = 0x02u;`; 4000 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_OPENVMS); }))) 4001 { 4002 mixin(enumMixinStr_ZIP_OPSYS_OPENVMS); 4003 } 4004 } 4005 4006 static if (!is(typeof(ZIP_OPSYS_UNIX))) 4007 { 4008 private enum enumMixinStr_ZIP_OPSYS_UNIX = `enum ZIP_OPSYS_UNIX = 0x03u;`; 4009 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_UNIX); }))) 4010 { 4011 mixin(enumMixinStr_ZIP_OPSYS_UNIX); 4012 } 4013 } 4014 4015 static if (!is(typeof(ZIP_OPSYS_VM_CMS))) 4016 { 4017 private enum enumMixinStr_ZIP_OPSYS_VM_CMS = `enum ZIP_OPSYS_VM_CMS = 0x04u;`; 4018 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_VM_CMS); }))) 4019 { 4020 mixin(enumMixinStr_ZIP_OPSYS_VM_CMS); 4021 } 4022 } 4023 4024 static if (!is(typeof(ZIP_OPSYS_ATARI_ST))) 4025 { 4026 private enum enumMixinStr_ZIP_OPSYS_ATARI_ST = `enum ZIP_OPSYS_ATARI_ST = 0x05u;`; 4027 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_ATARI_ST); }))) 4028 { 4029 mixin(enumMixinStr_ZIP_OPSYS_ATARI_ST); 4030 } 4031 } 4032 4033 static if (!is(typeof(ZIP_OPSYS_OS_2))) 4034 { 4035 private enum enumMixinStr_ZIP_OPSYS_OS_2 = `enum ZIP_OPSYS_OS_2 = 0x06u;`; 4036 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_OS_2); }))) 4037 { 4038 mixin(enumMixinStr_ZIP_OPSYS_OS_2); 4039 } 4040 } 4041 4042 static if (!is(typeof(ZIP_OPSYS_MACINTOSH))) 4043 { 4044 private enum enumMixinStr_ZIP_OPSYS_MACINTOSH = `enum ZIP_OPSYS_MACINTOSH = 0x07u;`; 4045 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_MACINTOSH); }))) 4046 { 4047 mixin(enumMixinStr_ZIP_OPSYS_MACINTOSH); 4048 } 4049 } 4050 4051 static if (!is(typeof(ZIP_OPSYS_Z_SYSTEM))) 4052 { 4053 private enum enumMixinStr_ZIP_OPSYS_Z_SYSTEM = `enum ZIP_OPSYS_Z_SYSTEM = 0x08u;`; 4054 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_Z_SYSTEM); }))) 4055 { 4056 mixin(enumMixinStr_ZIP_OPSYS_Z_SYSTEM); 4057 } 4058 } 4059 4060 static if (!is(typeof(ZIP_OPSYS_CPM))) 4061 { 4062 private enum enumMixinStr_ZIP_OPSYS_CPM = `enum ZIP_OPSYS_CPM = 0x09u;`; 4063 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_CPM); }))) 4064 { 4065 mixin(enumMixinStr_ZIP_OPSYS_CPM); 4066 } 4067 } 4068 4069 static if (!is(typeof(ZIP_OPSYS_WINDOWS_NTFS))) 4070 { 4071 private enum enumMixinStr_ZIP_OPSYS_WINDOWS_NTFS = `enum ZIP_OPSYS_WINDOWS_NTFS = 0x0au;`; 4072 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_WINDOWS_NTFS); }))) 4073 { 4074 mixin(enumMixinStr_ZIP_OPSYS_WINDOWS_NTFS); 4075 } 4076 } 4077 4078 static if (!is(typeof(ZIP_OPSYS_MVS))) 4079 { 4080 private enum enumMixinStr_ZIP_OPSYS_MVS = `enum ZIP_OPSYS_MVS = 0x0bu;`; 4081 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_MVS); }))) 4082 { 4083 mixin(enumMixinStr_ZIP_OPSYS_MVS); 4084 } 4085 } 4086 4087 static if (!is(typeof(ZIP_OPSYS_VSE))) 4088 { 4089 private enum enumMixinStr_ZIP_OPSYS_VSE = `enum ZIP_OPSYS_VSE = 0x0cu;`; 4090 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_VSE); }))) 4091 { 4092 mixin(enumMixinStr_ZIP_OPSYS_VSE); 4093 } 4094 } 4095 4096 static if (!is(typeof(ZIP_OPSYS_ACORN_RISC))) 4097 { 4098 private enum enumMixinStr_ZIP_OPSYS_ACORN_RISC = `enum ZIP_OPSYS_ACORN_RISC = 0x0du;`; 4099 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_ACORN_RISC); }))) 4100 { 4101 mixin(enumMixinStr_ZIP_OPSYS_ACORN_RISC); 4102 } 4103 } 4104 4105 static if (!is(typeof(ZIP_OPSYS_VFAT))) 4106 { 4107 private enum enumMixinStr_ZIP_OPSYS_VFAT = `enum ZIP_OPSYS_VFAT = 0x0eu;`; 4108 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_VFAT); }))) 4109 { 4110 mixin(enumMixinStr_ZIP_OPSYS_VFAT); 4111 } 4112 } 4113 4114 static if (!is(typeof(ZIP_OPSYS_ALTERNATE_MVS))) 4115 { 4116 private enum enumMixinStr_ZIP_OPSYS_ALTERNATE_MVS = `enum ZIP_OPSYS_ALTERNATE_MVS = 0x0fu;`; 4117 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_ALTERNATE_MVS); }))) 4118 { 4119 mixin(enumMixinStr_ZIP_OPSYS_ALTERNATE_MVS); 4120 } 4121 } 4122 4123 static if (!is(typeof(ZIP_OPSYS_BEOS))) 4124 { 4125 private enum enumMixinStr_ZIP_OPSYS_BEOS = `enum ZIP_OPSYS_BEOS = 0x10u;`; 4126 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_BEOS); }))) 4127 { 4128 mixin(enumMixinStr_ZIP_OPSYS_BEOS); 4129 } 4130 } 4131 4132 static if (!is(typeof(ZIP_OPSYS_TANDEM))) 4133 { 4134 private enum enumMixinStr_ZIP_OPSYS_TANDEM = `enum ZIP_OPSYS_TANDEM = 0x11u;`; 4135 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_TANDEM); }))) 4136 { 4137 mixin(enumMixinStr_ZIP_OPSYS_TANDEM); 4138 } 4139 } 4140 4141 static if (!is(typeof(ZIP_OPSYS_OS_400))) 4142 { 4143 private enum enumMixinStr_ZIP_OPSYS_OS_400 = `enum ZIP_OPSYS_OS_400 = 0x12u;`; 4144 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_OS_400); }))) 4145 { 4146 mixin(enumMixinStr_ZIP_OPSYS_OS_400); 4147 } 4148 } 4149 4150 static if (!is(typeof(ZIP_OPSYS_OS_X))) 4151 { 4152 private enum enumMixinStr_ZIP_OPSYS_OS_X = `enum ZIP_OPSYS_OS_X = 0x13u;`; 4153 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_OS_X); }))) 4154 { 4155 mixin(enumMixinStr_ZIP_OPSYS_OS_X); 4156 } 4157 } 4158 4159 static if (!is(typeof(ZIP_OPSYS_DEFAULT))) 4160 { 4161 private enum enumMixinStr_ZIP_OPSYS_DEFAULT = `enum ZIP_OPSYS_DEFAULT = 0x03u;`; 4162 static if (is(typeof({ mixin(enumMixinStr_ZIP_OPSYS_DEFAULT); }))) 4163 { 4164 mixin(enumMixinStr_ZIP_OPSYS_DEFAULT); 4165 } 4166 } 4167 4168 static if (!is(typeof(ZIP_SOURCE_SUPPORTS_READABLE))) 4169 { 4170 private enum enumMixinStr_ZIP_SOURCE_SUPPORTS_READABLE = `enum ZIP_SOURCE_SUPPORTS_READABLE = ( ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_OPEN ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_READ ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_CLOSE ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_STAT ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_ERROR ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_FREE ) ) );`; 4171 static if (is(typeof({ mixin(enumMixinStr_ZIP_SOURCE_SUPPORTS_READABLE); }))) 4172 { 4173 mixin(enumMixinStr_ZIP_SOURCE_SUPPORTS_READABLE); 4174 } 4175 } 4176 4177 static if (!is(typeof(ZIP_SOURCE_SUPPORTS_SEEKABLE))) 4178 { 4179 private enum enumMixinStr_ZIP_SOURCE_SUPPORTS_SEEKABLE = `enum ZIP_SOURCE_SUPPORTS_SEEKABLE = ( ( ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_OPEN ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_READ ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_CLOSE ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_STAT ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_ERROR ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_FREE ) ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_SEEK ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_TELL ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_SUPPORTS ) ) );`; 4180 static if (is(typeof({ mixin(enumMixinStr_ZIP_SOURCE_SUPPORTS_SEEKABLE); }))) 4181 { 4182 mixin(enumMixinStr_ZIP_SOURCE_SUPPORTS_SEEKABLE); 4183 } 4184 } 4185 4186 static if (!is(typeof(ZIP_SOURCE_SUPPORTS_WRITABLE))) 4187 { 4188 private enum enumMixinStr_ZIP_SOURCE_SUPPORTS_WRITABLE = `enum ZIP_SOURCE_SUPPORTS_WRITABLE = ( ( ( ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_OPEN ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_READ ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_CLOSE ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_STAT ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_ERROR ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_FREE ) ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_SEEK ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_TELL ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_SUPPORTS ) ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_BEGIN_WRITE ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_COMMIT_WRITE ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_ROLLBACK_WRITE ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_WRITE ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_SEEK_WRITE ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_TELL_WRITE ) ) | ( ( cast( zip_int64_t ) 1 ) << ( ZIP_SOURCE_REMOVE ) ) );`; 4189 static if (is(typeof({ mixin(enumMixinStr_ZIP_SOURCE_SUPPORTS_WRITABLE); }))) 4190 { 4191 mixin(enumMixinStr_ZIP_SOURCE_SUPPORTS_WRITABLE); 4192 } 4193 } 4194 4195 static if (!is(typeof(ZIP_STAT_NAME))) 4196 { 4197 private enum enumMixinStr_ZIP_STAT_NAME = `enum ZIP_STAT_NAME = 0x0001u;`; 4198 static if (is(typeof({ mixin(enumMixinStr_ZIP_STAT_NAME); }))) 4199 { 4200 mixin(enumMixinStr_ZIP_STAT_NAME); 4201 } 4202 } 4203 4204 static if (!is(typeof(ZIP_STAT_INDEX))) 4205 { 4206 private enum enumMixinStr_ZIP_STAT_INDEX = `enum ZIP_STAT_INDEX = 0x0002u;`; 4207 static if (is(typeof({ mixin(enumMixinStr_ZIP_STAT_INDEX); }))) 4208 { 4209 mixin(enumMixinStr_ZIP_STAT_INDEX); 4210 } 4211 } 4212 4213 static if (!is(typeof(ZIP_STAT_SIZE))) 4214 { 4215 private enum enumMixinStr_ZIP_STAT_SIZE = `enum ZIP_STAT_SIZE = 0x0004u;`; 4216 static if (is(typeof({ mixin(enumMixinStr_ZIP_STAT_SIZE); }))) 4217 { 4218 mixin(enumMixinStr_ZIP_STAT_SIZE); 4219 } 4220 } 4221 4222 static if (!is(typeof(ZIP_STAT_COMP_SIZE))) 4223 { 4224 private enum enumMixinStr_ZIP_STAT_COMP_SIZE = `enum ZIP_STAT_COMP_SIZE = 0x0008u;`; 4225 static if (is(typeof({ mixin(enumMixinStr_ZIP_STAT_COMP_SIZE); }))) 4226 { 4227 mixin(enumMixinStr_ZIP_STAT_COMP_SIZE); 4228 } 4229 } 4230 4231 static if (!is(typeof(ZIP_STAT_MTIME))) 4232 { 4233 private enum enumMixinStr_ZIP_STAT_MTIME = `enum ZIP_STAT_MTIME = 0x0010u;`; 4234 static if (is(typeof({ mixin(enumMixinStr_ZIP_STAT_MTIME); }))) 4235 { 4236 mixin(enumMixinStr_ZIP_STAT_MTIME); 4237 } 4238 } 4239 4240 static if (!is(typeof(ZIP_STAT_CRC))) 4241 { 4242 private enum enumMixinStr_ZIP_STAT_CRC = `enum ZIP_STAT_CRC = 0x0020u;`; 4243 static if (is(typeof({ mixin(enumMixinStr_ZIP_STAT_CRC); }))) 4244 { 4245 mixin(enumMixinStr_ZIP_STAT_CRC); 4246 } 4247 } 4248 4249 static if (!is(typeof(ZIP_STAT_COMP_METHOD))) 4250 { 4251 private enum enumMixinStr_ZIP_STAT_COMP_METHOD = `enum ZIP_STAT_COMP_METHOD = 0x0040u;`; 4252 static if (is(typeof({ mixin(enumMixinStr_ZIP_STAT_COMP_METHOD); }))) 4253 { 4254 mixin(enumMixinStr_ZIP_STAT_COMP_METHOD); 4255 } 4256 } 4257 4258 static if (!is(typeof(ZIP_STAT_ENCRYPTION_METHOD))) 4259 { 4260 private enum enumMixinStr_ZIP_STAT_ENCRYPTION_METHOD = `enum ZIP_STAT_ENCRYPTION_METHOD = 0x0080u;`; 4261 static if (is(typeof({ mixin(enumMixinStr_ZIP_STAT_ENCRYPTION_METHOD); }))) 4262 { 4263 mixin(enumMixinStr_ZIP_STAT_ENCRYPTION_METHOD); 4264 } 4265 } 4266 4267 static if (!is(typeof(ZIP_STAT_FLAGS))) 4268 { 4269 private enum enumMixinStr_ZIP_STAT_FLAGS = `enum ZIP_STAT_FLAGS = 0x0100u;`; 4270 static if (is(typeof({ mixin(enumMixinStr_ZIP_STAT_FLAGS); }))) 4271 { 4272 mixin(enumMixinStr_ZIP_STAT_FLAGS); 4273 } 4274 } 4275 4276 static if (!is(typeof(LIBZIP_VERSION))) 4277 { 4278 private enum enumMixinStr_LIBZIP_VERSION = `enum LIBZIP_VERSION = "1.5.1";`; 4279 static if (is(typeof({ mixin(enumMixinStr_LIBZIP_VERSION); }))) 4280 { 4281 mixin(enumMixinStr_LIBZIP_VERSION); 4282 } 4283 } 4284 4285 static if (!is(typeof(LIBZIP_VERSION_MAJOR))) 4286 { 4287 private enum enumMixinStr_LIBZIP_VERSION_MAJOR = `enum LIBZIP_VERSION_MAJOR = 1;`; 4288 static if (is(typeof({ mixin(enumMixinStr_LIBZIP_VERSION_MAJOR); }))) 4289 { 4290 mixin(enumMixinStr_LIBZIP_VERSION_MAJOR); 4291 } 4292 } 4293 4294 static if (!is(typeof(LIBZIP_VERSION_MINOR))) 4295 { 4296 private enum enumMixinStr_LIBZIP_VERSION_MINOR = `enum LIBZIP_VERSION_MINOR = 5;`; 4297 static if (is(typeof({ mixin(enumMixinStr_LIBZIP_VERSION_MINOR); }))) 4298 { 4299 mixin(enumMixinStr_LIBZIP_VERSION_MINOR); 4300 } 4301 } 4302 4303 static if (!is(typeof(LIBZIP_VERSION_MICRO))) 4304 { 4305 private enum enumMixinStr_LIBZIP_VERSION_MICRO = `enum LIBZIP_VERSION_MICRO = 1;`; 4306 static if (is(typeof({ mixin(enumMixinStr_LIBZIP_VERSION_MICRO); }))) 4307 { 4308 mixin(enumMixinStr_LIBZIP_VERSION_MICRO); 4309 } 4310 } 4311 4312 static if (!is(typeof(ZIP_INT8_MIN))) 4313 { 4314 private enum enumMixinStr_ZIP_INT8_MIN = `enum ZIP_INT8_MIN = ( - ZIP_INT8_MAX - 1 );`; 4315 static if (is(typeof({ mixin(enumMixinStr_ZIP_INT8_MIN); }))) 4316 { 4317 mixin(enumMixinStr_ZIP_INT8_MIN); 4318 } 4319 } 4320 4321 static if (!is(typeof(ZIP_INT8_MAX))) 4322 { 4323 private enum enumMixinStr_ZIP_INT8_MAX = `enum ZIP_INT8_MAX = 0x7f;`; 4324 static if (is(typeof({ mixin(enumMixinStr_ZIP_INT8_MAX); }))) 4325 { 4326 mixin(enumMixinStr_ZIP_INT8_MAX); 4327 } 4328 } 4329 4330 static if (!is(typeof(ZIP_UINT8_MAX))) 4331 { 4332 private enum enumMixinStr_ZIP_UINT8_MAX = `enum ZIP_UINT8_MAX = 0xff;`; 4333 static if (is(typeof({ mixin(enumMixinStr_ZIP_UINT8_MAX); }))) 4334 { 4335 mixin(enumMixinStr_ZIP_UINT8_MAX); 4336 } 4337 } 4338 4339 static if (!is(typeof(ZIP_INT16_MIN))) 4340 { 4341 private enum enumMixinStr_ZIP_INT16_MIN = `enum ZIP_INT16_MIN = ( - ZIP_INT16_MAX - 1 );`; 4342 static if (is(typeof({ mixin(enumMixinStr_ZIP_INT16_MIN); }))) 4343 { 4344 mixin(enumMixinStr_ZIP_INT16_MIN); 4345 } 4346 } 4347 4348 static if (!is(typeof(ZIP_INT16_MAX))) 4349 { 4350 private enum enumMixinStr_ZIP_INT16_MAX = `enum ZIP_INT16_MAX = 0x7fff;`; 4351 static if (is(typeof({ mixin(enumMixinStr_ZIP_INT16_MAX); }))) 4352 { 4353 mixin(enumMixinStr_ZIP_INT16_MAX); 4354 } 4355 } 4356 4357 static if (!is(typeof(ZIP_UINT16_MAX))) 4358 { 4359 private enum enumMixinStr_ZIP_UINT16_MAX = `enum ZIP_UINT16_MAX = 0xffff;`; 4360 static if (is(typeof({ mixin(enumMixinStr_ZIP_UINT16_MAX); }))) 4361 { 4362 mixin(enumMixinStr_ZIP_UINT16_MAX); 4363 } 4364 } 4365 4366 static if (!is(typeof(ZIP_INT32_MIN))) 4367 { 4368 private enum enumMixinStr_ZIP_INT32_MIN = `enum ZIP_INT32_MIN = ( - ZIP_INT32_MAX - 1L );`; 4369 static if (is(typeof({ mixin(enumMixinStr_ZIP_INT32_MIN); }))) 4370 { 4371 mixin(enumMixinStr_ZIP_INT32_MIN); 4372 } 4373 } 4374 4375 static if (!is(typeof(ZIP_INT32_MAX))) 4376 { 4377 private enum enumMixinStr_ZIP_INT32_MAX = `enum ZIP_INT32_MAX = 0x7fffffffL;`; 4378 static if (is(typeof({ mixin(enumMixinStr_ZIP_INT32_MAX); }))) 4379 { 4380 mixin(enumMixinStr_ZIP_INT32_MAX); 4381 } 4382 } 4383 4384 static if (!is(typeof(ZIP_UINT32_MAX))) 4385 { 4386 private enum enumMixinStr_ZIP_UINT32_MAX = `enum ZIP_UINT32_MAX = 0xffffffffLU;`; 4387 static if (is(typeof({ mixin(enumMixinStr_ZIP_UINT32_MAX); }))) 4388 { 4389 mixin(enumMixinStr_ZIP_UINT32_MAX); 4390 } 4391 } 4392 4393 static if (!is(typeof(ZIP_INT64_MIN))) 4394 { 4395 private enum enumMixinStr_ZIP_INT64_MIN = `enum ZIP_INT64_MIN = ( - ZIP_INT64_MAX - 1LL );`; 4396 static if (is(typeof({ mixin(enumMixinStr_ZIP_INT64_MIN); }))) 4397 { 4398 mixin(enumMixinStr_ZIP_INT64_MIN); 4399 } 4400 } 4401 4402 static if (!is(typeof(ZIP_INT64_MAX))) 4403 { 4404 private enum enumMixinStr_ZIP_INT64_MAX = `enum ZIP_INT64_MAX = 0x7fffffffffffffffL;`; 4405 static if (is(typeof({ mixin(enumMixinStr_ZIP_INT64_MAX); }))) 4406 { 4407 mixin(enumMixinStr_ZIP_INT64_MAX); 4408 } 4409 } 4410 4411 static if (!is(typeof(ZIP_UINT64_MAX))) 4412 { 4413 private enum enumMixinStr_ZIP_UINT64_MAX = `enum ZIP_UINT64_MAX = 0xffffffffffffffffLU;`; 4414 static if (is(typeof({ mixin(enumMixinStr_ZIP_UINT64_MAX); }))) 4415 { 4416 mixin(enumMixinStr_ZIP_UINT64_MAX); 4417 } 4418 } 4419 static if (!is(typeof(__GNUC_VA_LIST))) 4420 { 4421 private enum enumMixinStr___GNUC_VA_LIST = `enum __GNUC_VA_LIST = 1;`; 4422 static if (is(typeof({ mixin(enumMixinStr___GNUC_VA_LIST); }))) 4423 { 4424 mixin(enumMixinStr___GNUC_VA_LIST); 4425 } 4426 } 4427 4428 static if (!is(typeof(NULL))) 4429 { 4430 private enum enumMixinStr_NULL = `enum NULL = ( cast( void * ) 0 );`; 4431 static if (is(typeof({ mixin(enumMixinStr_NULL); }))) 4432 { 4433 mixin(enumMixinStr_NULL); 4434 } 4435 } 4436 4437 } 4438 4439 struct __va_list_tag;