/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
│                                                                              │
│ Permission to use, copy, modify, and/or distribute this software for         │
│ any purpose with or without fee is hereby granted, provided that the         │
│ above copyright notice and this permission notice appear in all copies.      │
│                                                                              │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
│ PERFORMANCE OF THIS SOFTWARE.                                                │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/errno.h"
#include "libc/str/str.h"
#include "libc/sysv/consts/af.h"
#include "libc/sysv/consts/at.h"
#include "libc/sysv/consts/clock.h"
#include "libc/sysv/consts/f.h"
#include "libc/sysv/consts/fd.h"
#include "libc/sysv/consts/ip.h"
#include "libc/sysv/consts/ipproto.h"
#include "libc/sysv/consts/lock.h"
#include "libc/sysv/consts/madv.h"
#include "libc/sysv/consts/map.h"
#include "libc/sysv/consts/msync.h"
#include "libc/sysv/consts/o.h"
#include "libc/sysv/consts/ok.h"
#include "libc/sysv/consts/rusage.h"
#include "libc/sysv/consts/sicode.h"
#include "libc/sysv/consts/sig.h"
#include "libc/sysv/consts/so.h"
#include "libc/sysv/consts/sock.h"
#include "libc/sysv/consts/sol.h"
#include "libc/sysv/consts/tcp.h"
#include "libc/sysv/consts/termios.h"
#include "libc/sysv/consts/w.h"
#include "libc/sysv/errfuns.h"
#include "tool/build/lib/case.h"
#include "tool/build/lib/endian.h"
#include "tool/build/lib/xlat.h"

#define XLAT(x, y) CASE(x, return y)

int XlatSignal(int x) {
  switch (x) {
    XLAT(1, SIGHUP);
    XLAT(2, SIGINT);
    XLAT(3, SIGQUIT);
    XLAT(4, SIGILL);
    XLAT(5, SIGTRAP);
    XLAT(6, SIGABRT);
    XLAT(7, SIGBUS);
    XLAT(8, SIGFPE);
    XLAT(9, SIGKILL);
    XLAT(10, SIGUSR1);
    XLAT(11, SIGSEGV);
    XLAT(12, SIGUSR2);
    XLAT(13, SIGPIPE);
    XLAT(14, SIGALRM);
    XLAT(15, SIGTERM);
    XLAT(17, SIGCHLD);
    XLAT(18, SIGCONT);
    XLAT(21, SIGTTIN);
    XLAT(22, SIGTTOU);
    XLAT(24, SIGXCPU);
    XLAT(25, SIGXFSZ);
    XLAT(26, SIGVTALRM);
    XLAT(27, SIGPROF);
    XLAT(28, SIGWINCH);
    XLAT(29, SIGIO);
    XLAT(19, SIGSTOP);
    XLAT(31, SIGSYS);
    XLAT(20, SIGTSTP);
    XLAT(23, SIGURG);
    default:
      return einval();
  }
}

int UnXlatSignal(int x) {
  if (x == SIGHUP) return 1;
  if (x == SIGINT) return 2;
  if (x == SIGQUIT) return 3;
  if (x == SIGILL) return 4;
  if (x == SIGTRAP) return 5;
  if (x == SIGABRT) return 6;
  if (x == SIGBUS) return 7;
  if (x == SIGFPE) return 8;
  if (x == SIGKILL) return 9;
  if (x == SIGUSR1) return 10;
  if (x == SIGSEGV) return 11;
  if (x == SIGUSR2) return 12;
  if (x == SIGPIPE) return 13;
  if (x == SIGALRM) return 14;
  if (x == SIGTERM) return 15;
  if (x == SIGCHLD) return 17;
  if (x == SIGCONT) return 18;
  if (x == SIGTTIN) return 21;
  if (x == SIGTTOU) return 22;
  if (x == SIGXCPU) return 24;
  if (x == SIGXFSZ) return 25;
  if (x == SIGVTALRM) return 26;
  if (x == SIGPROF) return 27;
  if (x == SIGWINCH) return 28;
  if (x == SIGIO) return 29;
  if (x == SIGSTOP) return 19;
  if (x == SIGSYS) return 31;
  if (x == SIGTSTP) return 20;
  if (x == SIGURG) return 23;
  return 15;
}

int UnXlatSicode(int sig, int code) {
  if (code == SI_USER) return 0;
  if (code == SI_QUEUE) return -1;
  if (code == SI_TIMER) return -2;
  if (code == SI_TKILL) return -6;
  if (code == SI_MESGQ) return -3;
  if (code == SI_ASYNCIO) return -4;
  if (code == SI_ASYNCNL) return -60;
  if (code == SI_KERNEL) return 0x80;
  if (sig == SIGCHLD) {
    if (code == CLD_EXITED) return 1;
    if (code == CLD_KILLED) return 2;
    if (code == CLD_DUMPED) return 3;
    if (code == CLD_TRAPPED) return 4;
    if (code == CLD_STOPPED) return 5;
    if (code == CLD_CONTINUED) return 6;
    return -1;
  }
  if (sig == SIGTRAP) {
    if (code == TRAP_BRKPT) return 1;
    if (code == TRAP_TRACE) return 2;
    return -1;
  }
  if (sig == SIGSEGV) {
    if (code == SEGV_MAPERR) return 1;
    if (code == SEGV_ACCERR) return 2;
    return -1;
  }
  if (sig == SIGFPE) {
    if (code == FPE_INTDIV) return 1;
    if (code == FPE_INTOVF) return 2;
    if (code == FPE_FLTDIV) return 3;
    if (code == FPE_FLTOVF) return 4;
    if (code == FPE_FLTUND) return 5;
    if (code == FPE_FLTRES) return 6;
    if (code == FPE_FLTINV) return 7;
    if (code == FPE_FLTSUB) return 8;
    return -1;
  }
  if (sig == SIGILL) {
    if (code == ILL_ILLOPC) return 1;
    if (code == ILL_ILLOPN) return 2;
    if (code == ILL_ILLADR) return 3;
    if (code == ILL_ILLTRP) return 4;
    if (code == ILL_PRVOPC) return 5;
    if (code == ILL_PRVREG) return 6;
    if (code == ILL_COPROC) return 7;
    if (code == ILL_BADSTK) return 8;
    return -1;
  }
  if (sig == SIGBUS) {
    if (code == BUS_ADRALN) return 1;
    if (code == BUS_ADRERR) return 2;
    if (code == BUS_OBJERR) return 3;
    if (code == BUS_MCEERR_AR) return 4;
    if (code == BUS_MCEERR_AO) return 5;
    return -1;
  }
  if (sig == SIGIO) {
    if (code == POLL_IN) return 1;
    if (code == POLL_OUT) return 2;
    if (code == POLL_MSG) return 3;
    if (code == POLL_ERR) return 4;
    if (code == POLL_PRI) return 5;
    if (code == POLL_HUP) return 6;
    return -1;
  }
  return -1;
}

int XlatSig(int x) {
  switch (x) {
    XLAT(0, SIG_BLOCK);
    XLAT(1, SIG_UNBLOCK);
    XLAT(2, SIG_SETMASK);
    default:
      return einval();
  }
}

int XlatRusage(int x) {
  switch (x) {
    XLAT(0, RUSAGE_SELF);
    XLAT(-1, RUSAGE_CHILDREN);
    XLAT(1, RUSAGE_THREAD);
    default:
      return einval();
  }
}

int XlatSocketFamily(int x) {
  switch (x) {
    XLAT(0, AF_UNSPEC);
    XLAT(1, AF_UNIX);
    XLAT(2, AF_INET);
    default:
      errno = EPFNOSUPPORT;
      return -1;
  }
}

int UnXlatSocketFamily(int x) {
  switch (x) {
    XLAT(AF_UNSPEC, 0);
    XLAT(AF_UNIX, 1);
    XLAT(AF_INET, 2);
    default:
      return x;
  }
}

int XlatSocketType(int x) {
  switch (x) {
    XLAT(1, SOCK_STREAM);
    XLAT(2, SOCK_DGRAM);
    default:
      return einval();
  }
}

int XlatSocketFlags(int flags) {
  unsigned res = 0;
  if (flags & 0x080000) res |= SOCK_CLOEXEC;
  if (flags & 0x000800) res |= SOCK_NONBLOCK;
  return res;
}

int XlatSocketProtocol(int x) {
  switch (x) {
    XLAT(0, 0);
    XLAT(6, IPPROTO_TCP);
    XLAT(17, IPPROTO_UDP);
    default:
      return einval();
  }
}

int XlatSocketLevel(int level) {
  switch (level) {
    XLAT(0, SOL_IP);
    XLAT(1, SOL_SOCKET);
    XLAT(6, SOL_TCP);
    XLAT(17, SOL_UDP);
    default:
      return einval();
  }
}

int XlatSocketOptname(int level, int optname) {
  if (level == SOL_SOCKET) {
    switch (optname) {
      XLAT(1, SO_DEBUG);
      XLAT(2, SO_REUSEADDR);
      XLAT(3, SO_TYPE);
      XLAT(4, SO_ERROR);
      XLAT(5, SO_DONTROUTE);
      XLAT(6, SO_BROADCAST);
      XLAT(7, SO_SNDBUF);
      XLAT(8, SO_RCVBUF);
      XLAT(9, SO_KEEPALIVE);
      XLAT(13, SO_LINGER);
      XLAT(15, SO_REUSEPORT);
      XLAT(18, SO_RCVLOWAT);
      XLAT(19, SO_SNDLOWAT);
      XLAT(30, SO_ACCEPTCONN);
      default:
        return einval();
    }
  }
  if (level == SOL_TCP) {
    switch (optname) {
      XLAT(1, TCP_NODELAY);
      XLAT(2, TCP_MAXSEG);
#if defined(TCP_CORK)
      XLAT(3, TCP_CORK);
#elif defined(TCP_NOPUSH)
      XLAT(3, TCP_NOPUSH);
#endif
#ifdef TCP_KEEPIDLE
      XLAT(4, TCP_KEEPIDLE);
#endif
#ifdef TCP_KEEPINTVL
      XLAT(5, TCP_KEEPINTVL);
#endif
#ifdef TCP_KEEPCNT
      XLAT(6, TCP_KEEPCNT);
#endif
#ifdef TCP_SYNCNT
      XLAT(7, TCP_SYNCNT);
#endif
#ifdef TCP_WINDOW_CLAMP
      XLAT(10, TCP_WINDOW_CLAMP);
#endif
#ifdef TCP_FASTOPEN
      XLAT(23, TCP_FASTOPEN);
#endif
#ifdef TCP_QUICKACK
      XLAT(12, TCP_QUICKACK);
#endif
#ifdef TCP_NOTSENT_LOWAT
      XLAT(25, TCP_NOTSENT_LOWAT);
#endif
#ifdef TCP_SAVE_SYN
      XLAT(27, TCP_SAVE_SYN);
#endif
#ifdef TCP_FASTOPEN_CONNECT
      XLAT(30, TCP_FASTOPEN_CONNECT);
#endif
      default:
        return einval();
    }
  }
  if (level == SOL_IP) {
    switch (optname) {
      XLAT(1, IP_TOS);
      XLAT(2, IP_TTL);
      XLAT(3, IP_HDRINCL);
      XLAT(14, IP_MTU);
      default:
        return einval();
    }
  }
  return einval();
}

int XlatAccess(int x) {
  int r = F_OK;
  if (x & 1) r |= X_OK;
  if (x & 2) r |= W_OK;
  if (x & 4) r |= R_OK;
  return r;
}

int XlatLock(int x) {
  int r = 0;
  if (x & 1) r |= LOCK_SH;
  if (x & 2) r |= LOCK_EX;
  if (x & 4) r |= LOCK_NB;
  if (x & 8) r |= LOCK_UN;
  return r;
}

int XlatWait(int x) {
  int r = 0;
  if (x & 1) r |= WNOHANG;
  if (x & 2) r |= WUNTRACED;
  if (x & 8) r |= WCONTINUED;
  return r;
}

int XlatMapFlags(int x) {
  int r = 0;
  if (x & 1) r |= MAP_SHARED;
  if (x & 2) r |= MAP_PRIVATE;
  if (x & 16) r |= MAP_FIXED;
  if (x & 32) r |= MAP_ANONYMOUS;
  return r;
}

int XlatMsyncFlags(int x) {
  unsigned res = 0;
  if (x & 1) res |= MS_ASYNC;
  if (x & 2) res |= MS_INVALIDATE;
  if (x & 4) res |= MS_SYNC;
  return res;
}

int XlatClock(int x) {
  switch (x) {
    XLAT(0, CLOCK_REALTIME);
    XLAT(1, CLOCK_MONOTONIC);
    XLAT(2, CLOCK_PROCESS_CPUTIME_ID);
#ifdef CLOCK_MONOTONIC_RAW
    XLAT(4, CLOCK_MONOTONIC_RAW);
#endif
    default:
      return x;
  }
}

int XlatAtf(int x) {
  int res = 0;
  if (x & 0x0100) res |= AT_SYMLINK_NOFOLLOW;
  if (x & 0x0200) res |= AT_REMOVEDIR;
  if (x & 0x0400) res |= AT_SYMLINK_FOLLOW;
  if (x & 0x1000) res |= AT_EMPTY_PATH;
  return res;
}

int XlatOpenMode(int flags) {
  switch (flags & 3) {
    case 0:
      return O_RDONLY;
    case 1:
      return O_WRONLY;
    case 2:
      return O_RDWR;
    default:
      for (;;) (void)0;
  }
}

int XlatOpenFlags(int flags) {
  int res;
  res = XlatOpenMode(flags);
  if (flags & 0x00400) res |= O_APPEND;
  if (flags & 0x00040) res |= O_CREAT;
  if (flags & 0x00080) res |= O_EXCL;
  if (flags & 0x00200) res |= O_TRUNC;
  if (flags & 0x00800) res |= O_NDELAY;
  if (flags & 0x04000) res |= O_DIRECT;
  if (flags & 0x10000) res |= O_DIRECTORY;
  if (flags & 0x20000) res |= O_NOFOLLOW;
  if (flags & 0x80000) res |= O_CLOEXEC;
  if (flags & 0x00100) res |= O_NOCTTY;
#ifdef O_ASYNC
  if (flags & 0x02000) res |= O_ASYNC;
#endif
#ifdef O_NOATIME
  if (flags & 0x40000) res |= O_NOATIME;
#endif
#ifdef O_DSYNC
  if (flags & 0x000001000) res |= O_DSYNC;
#endif
#ifdef O_SYNC
  if ((flags & 0x00101000) == 0x00101000) res |= O_SYNC;
#endif
  return res;
}

int XlatFcntlCmd(int x) {
  switch (x) {
    XLAT(1, F_GETFD);
    XLAT(2, F_SETFD);
    XLAT(3, F_GETFL);
    XLAT(4, F_SETFL);
    default:
      return einval();
  }
}

int XlatFcntlArg(int x) {
  switch (x) {
    XLAT(0, 0);
    XLAT(1, FD_CLOEXEC);
    XLAT(0x0800, O_NONBLOCK);
    default:
      return einval();
  }
}

int XlatAdvice(int x) {
  switch (x) {
    XLAT(0, MADV_NORMAL);
    XLAT(1, MADV_RANDOM);
    XLAT(2, MADV_SEQUENTIAL);
    XLAT(3, MADV_WILLNEED);
    XLAT(4, MADV_DONTNEED);
    XLAT(8, MADV_FREE);
    XLAT(12, MADV_MERGEABLE);
    default:
      return einval();
  }
}

void XlatSockaddrToHost(struct sockaddr_in *dst,
                        const struct sockaddr_in_bits *src) {
  memset(dst, 0, sizeof(*dst));
  dst->sin_family = XlatSocketFamily(Read16(src->sin_family));
  dst->sin_port = src->sin_port;
  dst->sin_addr.s_addr = src->sin_addr;
}

void XlatSockaddrToLinux(struct sockaddr_in_bits *dst,
                         const struct sockaddr_in *src) {
  memset(dst, 0, sizeof(*dst));
  Write16(dst->sin_family, UnXlatSocketFamily(src->sin_family));
  dst->sin_port = src->sin_port;
  dst->sin_addr = src->sin_addr.s_addr;
}

void XlatStatToLinux(struct stat_bits *dst, const struct stat *src) {
  Write64(dst->st_dev, src->st_dev);
  Write64(dst->st_ino, src->st_ino);
  Write64(dst->st_nlink, src->st_nlink);
  Write32(dst->st_mode, src->st_mode);
  Write32(dst->st_uid, src->st_uid);
  Write32(dst->st_gid, src->st_gid);
  Write32(dst->__pad, 0);
  Write64(dst->st_rdev, src->st_rdev);
  Write64(dst->st_size, src->st_size);
  Write64(dst->st_blksize, src->st_blksize);
  Write64(dst->st_blocks, src->st_blocks);
  Write64(dst->st_dev, src->st_dev);
  Write64(dst->st_atim.tv_sec, src->st_atim.tv_sec);
  Write64(dst->st_atim.tv_nsec, src->st_atim.tv_nsec);
  Write64(dst->st_mtim.tv_sec, src->st_mtim.tv_sec);
  Write64(dst->st_mtim.tv_nsec, src->st_mtim.tv_nsec);
  Write64(dst->st_ctim.tv_sec, src->st_ctim.tv_sec);
  Write64(dst->st_ctim.tv_nsec, src->st_ctim.tv_nsec);
}

void XlatRusageToLinux(struct rusage_bits *dst, const struct rusage *src) {
  Write64(dst->ru_utime.tv_sec, src->ru_utime.tv_sec);
  Write64(dst->ru_utime.tv_usec, src->ru_utime.tv_usec);
  Write64(dst->ru_stime.tv_sec, src->ru_stime.tv_sec);
  Write64(dst->ru_stime.tv_usec, src->ru_stime.tv_usec);
  Write64(dst->ru_maxrss, src->ru_maxrss);
  Write64(dst->ru_ixrss, src->ru_ixrss);
  Write64(dst->ru_idrss, src->ru_idrss);
  Write64(dst->ru_isrss, src->ru_isrss);
  Write64(dst->ru_minflt, src->ru_minflt);
  Write64(dst->ru_majflt, src->ru_majflt);
  Write64(dst->ru_nswap, src->ru_nswap);
  Write64(dst->ru_inblock, src->ru_inblock);
  Write64(dst->ru_oublock, src->ru_oublock);
  Write64(dst->ru_msgsnd, src->ru_msgsnd);
  Write64(dst->ru_msgrcv, src->ru_msgrcv);
  Write64(dst->ru_nsignals, src->ru_nsignals);
  Write64(dst->ru_nvcsw, src->ru_nvcsw);
  Write64(dst->ru_nivcsw, src->ru_nivcsw);
}

void XlatItimervalToLinux(struct itimerval_bits *dst,
                          const struct itimerval *src) {
  Write64(dst->it_interval.tv_sec, src->it_interval.tv_sec);
  Write64(dst->it_interval.tv_usec, src->it_interval.tv_usec);
  Write64(dst->it_value.tv_sec, src->it_value.tv_sec);
  Write64(dst->it_value.tv_usec, src->it_value.tv_usec);
}

void XlatLinuxToItimerval(struct itimerval *dst,
                          const struct itimerval_bits *src) {
  dst->it_interval.tv_sec = Read64(src->it_interval.tv_sec);
  dst->it_interval.tv_usec = Read64(src->it_interval.tv_usec);
  dst->it_value.tv_sec = Read64(src->it_value.tv_sec);
  dst->it_value.tv_usec = Read64(src->it_value.tv_usec);
}

void XlatWinsizeToLinux(struct winsize_bits *dst, const struct winsize *src) {
  memset(dst, 0, sizeof(*dst));
  Write16(dst->ws_row, src->ws_row);
  Write16(dst->ws_col, src->ws_col);
}

void XlatSigsetToLinux(uint8_t dst[8], const sigset_t *src) {
  int i;
  uint64_t x;
  for (x = i = 0; i < 64; ++i) {
    if (sigismember(src, i + 1)) {
      x |= 1ull << i;
    }
  }
  Write64(dst, x);
}

void XlatLinuxToSigset(sigset_t *dst, const uint8_t src[8]) {
  int i;
  uint64_t x;
  x = Read64(src);
  sigemptyset(dst);
  for (i = 0; i < 64; ++i) {
    if ((1ull << i) & x) {
      sigaddset(dst, i + 1);
    }
  }
}

static int XlatTermiosCflag(int x) {
  int r = 0;
  if (x & 0x0001) r |= ISIG;
  if (x & 0x0040) r |= CSTOPB;
  if (x & 0x0080) r |= CREAD;
  if (x & 0x0100) r |= PARENB;
  if (x & 0x0200) r |= PARODD;
  if (x & 0x0400) r |= HUPCL;
  if (x & 0x0800) r |= CLOCAL;
  if ((x & 0x0030) == 0x0010) {
    r |= CS6;
  } else if ((x & 0x0030) == 0x0020) {
    r |= CS7;
  } else if ((x & 0x0030) == 0x0030) {
    r |= CS8;
  }
  return r;
}

static int UnXlatTermiosCflag(int x) {
  int r = 0;
  if (x & ISIG) r |= 0x0001;
  if (x & CSTOPB) r |= 0x0040;
  if (x & CREAD) r |= 0x0080;
  if (x & PARENB) r |= 0x0100;
  if (x & PARODD) r |= 0x0200;
  if (x & HUPCL) r |= 0x0400;
  if (x & CLOCAL) r |= 0x0800;
  if ((x & CSIZE) == CS5) {
    r |= 0x0000;
  } else if ((x & CSIZE) == CS6) {
    r |= 0x0010;
  } else if ((x & CSIZE) == CS7) {
    r |= 0x0020;
  } else if ((x & CSIZE) == CS8) {
    r |= 0x0030;
  }
  return r;
}

static int XlatTermiosLflag(int x) {
  int r = 0;
  if (x & 0x0001) r |= ISIG;
  if (x & 0x0002) r |= ICANON;
  if (x & 0x0008) r |= ECHO;
  if (x & 0x0010) r |= ECHOE;
  if (x & 0x0020) r |= ECHOK;
  if (x & 0x0040) r |= ECHONL;
  if (x & 0x0080) r |= NOFLSH;
  if (x & 0x0100) r |= TOSTOP;
  if (x & 0x8000) r |= IEXTEN;
#ifdef ECHOCTL
  if (x & 0x0200) r |= ECHOCTL;
#endif
#ifdef ECHOPRT
  if (x & 0x0400) r |= ECHOPRT;
#endif
#ifdef ECHOKE
  if (x & 0x0800) r |= ECHOKE;
#endif
#ifdef FLUSHO
  if (x & 0x1000) r |= FLUSHO;
#endif
#ifdef PENDIN
  if (x & 0x4000) r |= PENDIN;
#endif
#ifdef XCASE
  if (x & 0x0004) r |= XCASE;
#endif
  return r;
}

static int UnXlatTermiosLflag(int x) {
  int r = 0;
  if (x & ISIG) r |= 0x0001;
  if (x & ICANON) r |= 0x0002;
  if (x & ECHO) r |= 0x0008;
  if (x & ECHOE) r |= 0x0010;
  if (x & ECHOK) r |= 0x0020;
  if (x & ECHONL) r |= 0x0040;
  if (x & NOFLSH) r |= 0x0080;
  if (x & TOSTOP) r |= 0x0100;
  if (x & IEXTEN) r |= 0x8000;
#ifdef ECHOCTL
  if (x & ECHOCTL) r |= 0x0200;
#endif
#ifdef ECHOPRT
  if (x & ECHOPRT) r |= 0x0400;
#endif
#ifdef ECHOKE
  if (x & ECHOKE) r |= 0x0800;
#endif
#ifdef FLUSHO
  if (x & FLUSHO) r |= 0x1000;
#endif
#ifdef PENDIN
  if (x & PENDIN) r |= 0x4000;
#endif
#ifdef XCASE
  if (x & XCASE) r |= 0x0004;
#endif
  return r;
}

static int XlatTermiosIflag(int x) {
  int r = 0;
  if (x & 0x0001) r |= IGNBRK;
  if (x & 0x0002) r |= BRKINT;
  if (x & 0x0004) r |= IGNPAR;
  if (x & 0x0008) r |= PARMRK;
  if (x & 0x0010) r |= INPCK;
  if (x & 0x0020) r |= ISTRIP;
  if (x & 0x0040) r |= INLCR;
  if (x & 0x0080) r |= IGNCR;
  if (x & 0x0100) r |= ICRNL;
  if (x & 0x0400) r |= IXON;
  if (x & 0x0800) r |= IXANY;
  if (x & 0x1000) r |= IXOFF;
#ifdef IMAXBEL
  if (x & 0x2000) r |= IMAXBEL;
#endif
#ifdef IUTF8
  if (x & 0x4000) r |= IUTF8;
#endif
#ifdef IUCLC
  if (x & 0x0200) r |= IUCLC;
#endif
  return r;
}

static int UnXlatTermiosIflag(int x) {
  int r = 0;
  if (x & IGNBRK) r |= 0x0001;
  if (x & BRKINT) r |= 0x0002;
  if (x & IGNPAR) r |= 0x0004;
  if (x & PARMRK) r |= 0x0008;
  if (x & INPCK) r |= 0x0010;
  if (x & ISTRIP) r |= 0x0020;
  if (x & INLCR) r |= 0x0040;
  if (x & IGNCR) r |= 0x0080;
  if (x & ICRNL) r |= 0x0100;
  if (x & IXON) r |= 0x0400;
  if (x & IXANY) r |= 0x0800;
  if (x & IXOFF) r |= 0x1000;
#ifdef IMAXBEL
  if (x & IMAXBEL) r |= 0x2000;
#endif
#ifdef IUTF8
  if (x & IUTF8) r |= 0x4000;
#endif
#ifdef IUCLC
  if (x & IUCLC) r |= 0x0200;
#endif
  return r;
}

static int XlatTermiosOflag(int x) {
  int r = 0;
  if (x & 0x0001) r |= OPOST;
#ifdef ONLCR
  if (x & 0x0004) r |= ONLCR;
#endif
#ifdef OCRNL
  if (x & 0x0008) r |= OCRNL;
#endif
#ifdef ONOCR
  if (x & 0x0010) r |= ONOCR;
#endif
#ifdef ONLRET
  if (x & 0x0020) r |= ONLRET;
#endif
#ifdef OFILL
  if (x & 0x0040) r |= OFILL;
#endif
#ifdef OFDEL
  if (x & 0x0080) r |= OFDEL;
#endif
#ifdef NLDLY
  if ((x & 0x0100) == 0x0000) {
    r |= NL0;
  } else if ((x & 0x0100) == 0x0100) {
    r |= NL1;
#ifdef NL2
  } else if ((x & 0x0100) == 0x0000) {
    r |= NL2;
#endif
#ifdef NL3
  } else if ((x & 0x0100) == 0x0000) {
    r |= NL3;
#endif
  }
#endif
#ifdef CRDLY
  if ((x & 0x0600) == 0x0000) {
    r |= CR0;
  } else if ((x & 0x0600) == 0x0200) {
    r |= CR1;
  } else if ((x & 0x0600) == 0x0400) {
    r |= CR2;
  } else if ((x & 0x0600) == 0x0600) {
    r |= CR3;
  }
#endif
#ifdef TABDLY
  if ((x & 0x1800) == 0x0000) {
    r |= TAB0;
#ifdef TAB1
  } else if ((x & 0x1800) == 0x0800) {
    r |= TAB1;
#endif
#ifdef TAB1
  } else if ((x & 0x1800) == 0x1000) {
    r |= TAB2;
#endif
  } else if ((x & 0x1800) == 0x1800) {
    r |= TAB3;
  }
#endif
#ifdef BSDLY
  if ((x & 0x2000) == 0x0000) {
    r |= BS0;
  } else if ((x & 0x2000) == 0x2000) {
    r |= BS1;
  }
#endif
#ifdef VTBDLY
  if ((x & 0x4000) == 0x0000) {
    r |= VT0;
  } else if ((x & 0x4000) == 0x4000) {
    r |= VT1;
  }
#endif
#ifdef FFBDLY
  if ((x & 0x8000) == 0x0000) {
    r |= FF0;
  } else if ((x & 0x8000) == 0x8000) {
    r |= FF1;
  }
#endif
#ifdef OLCUC
  if (x & 0x0002) r |= OLCUC;
#endif
  return r;
}

static int UnXlatTermiosOflag(int x) {
  int r = 0;
  if (x & OPOST) r |= 0x0001;
#ifdef ONLCR
  if (x & ONLCR) r |= 0x0004;
#endif
#ifdef OCRNL
  if (x & OCRNL) r |= 0x0008;
#endif
#ifdef ONOCR
  if (x & ONOCR) r |= 0x0010;
#endif
#ifdef ONLRET
  if (x & ONLRET) r |= 0x0020;
#endif
#ifdef OFILL
  if (x & OFILL) r |= 0x0040;
#endif
#ifdef OFDEL
  if (x & OFDEL) r |= 0x0080;
#endif
#ifdef NLDLY
  if ((x & NLDLY) == NL0) {
    r |= 0x0000;
  } else if ((x & NLDLY) == NL1) {
    r |= 0x0100;
#ifdef NL2
  } else if ((x & NLDLY) == NL2) {
    r |= 0x0000;
#endif
#ifdef NL3
  } else if ((x & NLDLY) == NL3) {
    r |= 0x0000;
#endif
  }
#endif
#ifdef CRDLY
  if ((x & CRDLY) == CR0) {
    r |= 0x0000;
  } else if ((x & CRDLY) == CR1) {
    r |= 0x0200;
  } else if ((x & CRDLY) == CR2) {
    r |= 0x0400;
  } else if ((x & CRDLY) == CR3) {
    r |= 0x0600;
  }
#endif
#ifdef TABDLY
  if ((x & TABDLY) == TAB0) {
    r |= 0x0000;
#ifdef TAB1
  } else if ((x & TABDLY) == TAB1) {
    r |= 0x0800;
#endif
#ifdef TAB2
  } else if ((x & TABDLY) == TAB2) {
    r |= 0x1000;
#endif
  } else if ((x & TABDLY) == TAB3) {
    r |= 0x1800;
  }
#endif
#ifdef BSDLY
  if ((x & BSDLY) == BS0) {
    r |= 0x0000;
  } else if ((x & BSDLY) == BS1) {
    r |= 0x2000;
  }
#endif
#ifdef VTDLY
  if ((x & VTDLY) == VT0) {
    r |= 0x0000;
  } else if ((x & VTDLY) == VT1) {
    r |= 0x4000;
  }
#endif
#ifdef FFDLY
  if ((x & FFDLY) == FF0) {
    r |= 0x0000;
  } else if ((x & FFDLY) == FF1) {
    r |= 0x8000;
  }
#endif
#ifdef OLCUC
  if (x & OLCUC) r |= 0x0002;
#endif
  return r;
}

static void XlatTermiosCc(struct termios *dst, const struct termios_bits *src) {
  dst->c_cc[VINTR] = src->c_cc[0];
  dst->c_cc[VQUIT] = src->c_cc[1];
  dst->c_cc[VERASE] = src->c_cc[2];
  dst->c_cc[VKILL] = src->c_cc[3];
  dst->c_cc[VEOF] = src->c_cc[4];
  dst->c_cc[VTIME] = src->c_cc[5];
  dst->c_cc[VMIN] = src->c_cc[6];
  dst->c_cc[VSTART] = src->c_cc[8];
  dst->c_cc[VSTOP] = src->c_cc[9];
  dst->c_cc[VSUSP] = src->c_cc[10];
  dst->c_cc[VEOL] = src->c_cc[11];
#ifdef VSWTC
  dst->c_cc[VSWTC] = src->c_cc[7];
#endif
#ifdef VREPRINT
  dst->c_cc[VREPRINT] = src->c_cc[12];
#endif
#ifdef VDISCARD
  dst->c_cc[VDISCARD] = src->c_cc[13];
#endif
#ifdef VWERASE
  dst->c_cc[VWERASE] = src->c_cc[14];
#endif
#ifdef VLNEXT
  dst->c_cc[VLNEXT] = src->c_cc[15];
#endif
#ifdef VEOL2
  dst->c_cc[VEOL2] = src->c_cc[16];
#endif
}

static void UnXlatTermiosCc(struct termios_bits *dst,
                            const struct termios *src) {
  dst->c_cc[0] = src->c_cc[VINTR];
  dst->c_cc[1] = src->c_cc[VQUIT];
  dst->c_cc[2] = src->c_cc[VERASE];
  dst->c_cc[3] = src->c_cc[VKILL];
  dst->c_cc[4] = src->c_cc[VEOF];
  dst->c_cc[5] = src->c_cc[VTIME];
  dst->c_cc[6] = src->c_cc[VMIN];
  dst->c_cc[8] = src->c_cc[VSTART];
  dst->c_cc[9] = src->c_cc[VSTOP];
  dst->c_cc[10] = src->c_cc[VSUSP];
  dst->c_cc[11] = src->c_cc[VEOL];
#ifdef VSWTC
  dst->c_cc[7] = src->c_cc[VSWTC];
#endif
#ifdef VREPRINT
  dst->c_cc[12] = src->c_cc[VREPRINT];
#endif
#ifdef VDISCARD
  dst->c_cc[13] = src->c_cc[VDISCARD];
#endif
#ifdef VWERASE
  dst->c_cc[14] = src->c_cc[VWERASE];
#endif
#ifdef VLNEXT
  dst->c_cc[15] = src->c_cc[VLNEXT];
#endif
#ifdef VEOL2
  dst->c_cc[16] = src->c_cc[VEOL2];
#endif
}

void XlatLinuxToTermios(struct termios *dst, const struct termios_bits *src) {
  memset(dst, 0, sizeof(*dst));
  dst->c_iflag = XlatTermiosIflag(Read32(src->c_iflag));
  dst->c_oflag = XlatTermiosOflag(Read32(src->c_oflag));
  dst->c_cflag = XlatTermiosCflag(Read32(src->c_cflag));
  dst->c_lflag = XlatTermiosLflag(Read32(src->c_lflag));
  XlatTermiosCc(dst, src);
}

void XlatTermiosToLinux(struct termios_bits *dst, const struct termios *src) {
  memset(dst, 0, sizeof(*dst));
  Write32(dst->c_iflag, UnXlatTermiosIflag(src->c_iflag));
  Write32(dst->c_oflag, UnXlatTermiosOflag(src->c_oflag));
  Write32(dst->c_cflag, UnXlatTermiosCflag(src->c_cflag));
  Write32(dst->c_lflag, UnXlatTermiosLflag(src->c_lflag));
  UnXlatTermiosCc(dst, src);
}