pkgs/unix_api/lib/src/constants.g.dart

// AUTO GENERATED FILE, DO NOT EDIT.
// Regenerate with `dart run tool/build_constants.dart`.

// ignore_for_file: non_constant_identifier_names

import 'constant_bindings.g.dart';

int get DT_BLK {
  final v = get_DT_BLK();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('DT_BLK');
  } else {
    return v;
  }
}

int get DT_CHR {
  final v = get_DT_CHR();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('DT_CHR');
  } else {
    return v;
  }
}

int get DT_DIR {
  final v = get_DT_DIR();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('DT_DIR');
  } else {
    return v;
  }
}

int get DT_FIFO {
  final v = get_DT_FIFO();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('DT_FIFO');
  } else {
    return v;
  }
}

int get DT_LNK {
  final v = get_DT_LNK();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('DT_LNK');
  } else {
    return v;
  }
}

int get DT_REG {
  final v = get_DT_REG();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('DT_REG');
  } else {
    return v;
  }
}

int get DT_SOCK {
  final v = get_DT_SOCK();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('DT_SOCK');
  } else {
    return v;
  }
}

int get DT_UNKNOWN {
  final v = get_DT_UNKNOWN();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('DT_UNKNOWN');
  } else {
    return v;
  }
}

int get EACCES {
  final v = get_EACCES();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('EACCES');
  } else {
    return v;
  }
}

int get EBADF {
  final v = get_EBADF();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('EBADF');
  } else {
    return v;
  }
}

int get EDOM {
  final v = get_EDOM();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('EDOM');
  } else {
    return v;
  }
}

int get EEXIST {
  final v = get_EEXIST();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('EEXIST');
  } else {
    return v;
  }
}

int get EINTR {
  final v = get_EINTR();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('EINTR');
  } else {
    return v;
  }
}

int get EINVAL {
  final v = get_EINVAL();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('EINVAL');
  } else {
    return v;
  }
}

int get EMFILE {
  final v = get_EMFILE();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('EMFILE');
  } else {
    return v;
  }
}

int get ENOENT {
  final v = get_ENOENT();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('ENOENT');
  } else {
    return v;
  }
}

int get ENOSPC {
  final v = get_ENOSPC();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('ENOSPC');
  } else {
    return v;
  }
}

int get ENOSYS {
  final v = get_ENOSYS();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('ENOSYS');
  } else {
    return v;
  }
}

int get ENOTDIR {
  final v = get_ENOTDIR();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('ENOTDIR');
  } else {
    return v;
  }
}

int get ENOTEMPTY {
  final v = get_ENOTEMPTY();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('ENOTEMPTY');
  } else {
    return v;
  }
}

int get EPERM {
  final v = get_EPERM();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('EPERM');
  } else {
    return v;
  }
}

int get ETIMEDOUT {
  final v = get_ETIMEDOUT();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('ETIMEDOUT');
  } else {
    return v;
  }
}

int get AT_FDCWD {
  final v = get_AT_FDCWD();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('AT_FDCWD');
  } else {
    return v;
  }
}

int get AT_REMOVEDIR {
  final v = get_AT_REMOVEDIR();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('AT_REMOVEDIR');
  } else {
    return v;
  }
}

int get O_APPEND {
  final v = get_O_APPEND();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('O_APPEND');
  } else {
    return v;
  }
}

int get O_CLOEXEC {
  final v = get_O_CLOEXEC();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('O_CLOEXEC');
  } else {
    return v;
  }
}

int get O_CREAT {
  final v = get_O_CREAT();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('O_CREAT');
  } else {
    return v;
  }
}

int get O_DIRECTORY {
  final v = get_O_DIRECTORY();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('O_DIRECTORY');
  } else {
    return v;
  }
}

int get O_EXCL {
  final v = get_O_EXCL();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('O_EXCL');
  } else {
    return v;
  }
}

int get O_RDONLY {
  final v = get_O_RDONLY();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('O_RDONLY');
  } else {
    return v;
  }
}

int get O_TRUNC {
  final v = get_O_TRUNC();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('O_TRUNC');
  } else {
    return v;
  }
}

int get O_WRONLY {
  final v = get_O_WRONLY();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('O_WRONLY');
  } else {
    return v;
  }
}

int get PATH_MAX {
  final v = get_PATH_MAX();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('PATH_MAX');
  } else {
    return v;
  }
}

int get L_ctermid {
  final v = get_L_ctermid();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('L_ctermid');
  } else {
    return v;
  }
}

int get MAP_ANONYMOUS {
  final v = get_MAP_ANONYMOUS();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('MAP_ANONYMOUS');
  } else {
    return v;
  }
}

int get MAP_FIXED {
  final v = get_MAP_FIXED();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('MAP_FIXED');
  } else {
    return v;
  }
}

int get MAP_PRIVATE {
  final v = get_MAP_PRIVATE();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('MAP_PRIVATE');
  } else {
    return v;
  }
}

int get MAP_SHARED {
  final v = get_MAP_SHARED();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('MAP_SHARED');
  } else {
    return v;
  }
}

int get MCL_CURRENT {
  final v = get_MCL_CURRENT();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('MCL_CURRENT');
  } else {
    return v;
  }
}

int get MCL_FUTURE {
  final v = get_MCL_FUTURE();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('MCL_FUTURE');
  } else {
    return v;
  }
}

int get MS_ASYNC {
  final v = get_MS_ASYNC();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('MS_ASYNC');
  } else {
    return v;
  }
}

int get MS_INVALIDATE {
  final v = get_MS_INVALIDATE();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('MS_INVALIDATE');
  } else {
    return v;
  }
}

int get MS_SYNC {
  final v = get_MS_SYNC();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('MS_SYNC');
  } else {
    return v;
  }
}

int get POSIX_MADV_DONTNEED {
  final v = get_POSIX_MADV_DONTNEED();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('POSIX_MADV_DONTNEED');
  } else {
    return v;
  }
}

int get POSIX_MADV_NORMAL {
  final v = get_POSIX_MADV_NORMAL();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('POSIX_MADV_NORMAL');
  } else {
    return v;
  }
}

int get POSIX_MADV_RANDOM {
  final v = get_POSIX_MADV_RANDOM();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('POSIX_MADV_RANDOM');
  } else {
    return v;
  }
}

int get POSIX_MADV_SEQUENTIAL {
  final v = get_POSIX_MADV_SEQUENTIAL();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('POSIX_MADV_SEQUENTIAL');
  } else {
    return v;
  }
}

int get POSIX_MADV_WILLNEED {
  final v = get_POSIX_MADV_WILLNEED();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('POSIX_MADV_WILLNEED');
  } else {
    return v;
  }
}

int get POSIX_TYPED_MEM_ALLOCATE {
  final v = get_POSIX_TYPED_MEM_ALLOCATE();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('POSIX_TYPED_MEM_ALLOCATE');
  } else {
    return v;
  }
}

int get POSIX_TYPED_MEM_ALLOCATE_CONTIG {
  final v = get_POSIX_TYPED_MEM_ALLOCATE_CONTIG();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('POSIX_TYPED_MEM_ALLOCATE_CONTIG');
  } else {
    return v;
  }
}

int get POSIX_TYPED_MEM_MAP_ALLOCATABLE {
  final v = get_POSIX_TYPED_MEM_MAP_ALLOCATABLE();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('POSIX_TYPED_MEM_MAP_ALLOCATABLE');
  } else {
    return v;
  }
}

int get PROT_EXEC {
  final v = get_PROT_EXEC();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('PROT_EXEC');
  } else {
    return v;
  }
}

int get PROT_NONE {
  final v = get_PROT_NONE();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('PROT_NONE');
  } else {
    return v;
  }
}

int get PROT_READ {
  final v = get_PROT_READ();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('PROT_READ');
  } else {
    return v;
  }
}

int get PROT_WRITE {
  final v = get_PROT_WRITE();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('PROT_WRITE');
  } else {
    return v;
  }
}

int get AT_SYMLINK_NOFOLLOW {
  final v = get_AT_SYMLINK_NOFOLLOW();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('AT_SYMLINK_NOFOLLOW');
  } else {
    return v;
  }
}

int get AT_RESOLVE_BENEATH {
  final v = get_AT_RESOLVE_BENEATH();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('AT_RESOLVE_BENEATH');
  } else {
    return v;
  }
}

int get AT_EMPTY_PATH {
  final v = get_AT_EMPTY_PATH();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('AT_EMPTY_PATH');
  } else {
    return v;
  }
}

int get S_IEXEC {
  final v = get_S_IEXEC();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IEXEC');
  } else {
    return v;
  }
}

int get S_IFBLK {
  final v = get_S_IFBLK();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IFBLK');
  } else {
    return v;
  }
}

int get S_IFCHR {
  final v = get_S_IFCHR();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IFCHR');
  } else {
    return v;
  }
}

int get S_IFDIR {
  final v = get_S_IFDIR();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IFDIR');
  } else {
    return v;
  }
}

int get S_IFIFO {
  final v = get_S_IFIFO();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IFIFO');
  } else {
    return v;
  }
}

int get S_IFLNK {
  final v = get_S_IFLNK();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IFLNK');
  } else {
    return v;
  }
}

int get S_IFMT {
  final v = get_S_IFMT();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IFMT');
  } else {
    return v;
  }
}

int get S_IFREG {
  final v = get_S_IFREG();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IFREG');
  } else {
    return v;
  }
}

int get S_IFSOCK {
  final v = get_S_IFSOCK();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IFSOCK');
  } else {
    return v;
  }
}

int get S_IFWHT {
  final v = get_S_IFWHT();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IFWHT');
  } else {
    return v;
  }
}

int get S_IREAD {
  final v = get_S_IREAD();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IREAD');
  } else {
    return v;
  }
}

int get S_IRGRP {
  final v = get_S_IRGRP();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IRGRP');
  } else {
    return v;
  }
}

int get S_IROTH {
  final v = get_S_IROTH();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IROTH');
  } else {
    return v;
  }
}

int get S_IRUSR {
  final v = get_S_IRUSR();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IRUSR');
  } else {
    return v;
  }
}

int get S_IRWXG {
  final v = get_S_IRWXG();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IRWXG');
  } else {
    return v;
  }
}

int get S_IRWXO {
  final v = get_S_IRWXO();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IRWXO');
  } else {
    return v;
  }
}

int get S_IRWXU {
  final v = get_S_IRWXU();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IRWXU');
  } else {
    return v;
  }
}

int get S_ISGID {
  final v = get_S_ISGID();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_ISGID');
  } else {
    return v;
  }
}

int get S_ISTXT {
  final v = get_S_ISTXT();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_ISTXT');
  } else {
    return v;
  }
}

int get S_ISUID {
  final v = get_S_ISUID();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_ISUID');
  } else {
    return v;
  }
}

int get S_ISVTX {
  final v = get_S_ISVTX();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_ISVTX');
  } else {
    return v;
  }
}

int get S_IWGRP {
  final v = get_S_IWGRP();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IWGRP');
  } else {
    return v;
  }
}

int get S_IWOTH {
  final v = get_S_IWOTH();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IWOTH');
  } else {
    return v;
  }
}

int get S_IWRITE {
  final v = get_S_IWRITE();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IWRITE');
  } else {
    return v;
  }
}

int get S_IWUSR {
  final v = get_S_IWUSR();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IWUSR');
  } else {
    return v;
  }
}

int get S_IXGRP {
  final v = get_S_IXGRP();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IXGRP');
  } else {
    return v;
  }
}

int get S_IXOTH {
  final v = get_S_IXOTH();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IXOTH');
  } else {
    return v;
  }
}

int get S_IXUSR {
  final v = get_S_IXUSR();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('S_IXUSR');
  } else {
    return v;
  }
}

int get UF_APPEND {
  final v = get_UF_APPEND();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('UF_APPEND');
  } else {
    return v;
  }
}

int get UF_HIDDEN {
  final v = get_UF_HIDDEN();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('UF_HIDDEN');
  } else {
    return v;
  }
}

int get F_OK {
  final v = get_F_OK();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('F_OK');
  } else {
    return v;
  }
}

int get R_OK {
  final v = get_R_OK();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('R_OK');
  } else {
    return v;
  }
}

int get W_OK {
  final v = get_W_OK();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('W_OK');
  } else {
    return v;
  }
}

int get X_OK {
  final v = get_X_OK();
  if (v == libc_shim_UNDEFINED) {
    throw UnsupportedError('X_OK');
  } else {
    return v;
  }
}