(* Copyright (C) 1997-1999 NEC Research Institute.
 * Please see the file LICENSE for license information.
 *)
structure PosixPrimitive =
   struct
      type nullString = string
      type cstring = C.CS.cs
      type cstringArray = C.CSS.css

      type fd = int
      type pid = int
      type uid = word
      type gid = word
      type signal = int
      type size = int
      type ssize = int
      type mode = word
      type time = int
      datatype file_desc = FD of int
	 
      structure Error =
	 struct
	    type syserror = int

	    val getErrno = _prim "MLTON_errno": unit -> int;
	    val clearErrno = _prim "MLTON_clearErrno": unit -> unit;
	    val strerror = _prim "MLTON_strerror": syserror -> C.CS.cs;

	    val acces = _prim "EACCES": syserror;
	    val again = _prim "EAGAIN": syserror;
	    val badf = _prim "EBADF": syserror;
	    val badmsg = _prim "EBADMSG": syserror;
	    val busy = _prim "EBUSY": syserror;
	    val canceled = _prim "ECANCELED": syserror;
	    val child = _prim "ECHILD": syserror;
	    val deadlk = _prim "EDEADLK": syserror;
	    val dom = _prim "EDOM": syserror;
	    val exist = _prim "EEXIST": syserror;
	    val fault = _prim "EFAULT": syserror;
	    val fbig = _prim "EFBIG": syserror;
	    val inprogress = _prim "EINPROGRESS": syserror;
	    val intr = _prim "EINTR": syserror;
	    val inval = _prim "EINVAL": syserror;
	    val io = _prim "EIO": syserror;
	    val isdir = _prim "EISDIR": syserror;
	    val loop = _prim "ELOOP": syserror;
	    val mfile = _prim "EMFILE": syserror;
	    val mlink = _prim "EMLINK": syserror;
	    val msgsize = _prim "EMSGSIZE": syserror;
	    val nametoolong = _prim "ENAMETOOLONG": syserror;
	    val nfile = _prim "ENFILE": syserror;
	    val nodev = _prim "ENODEV": syserror;
	    val noent = _prim "ENOENT": syserror;
	    val noexec = _prim "ENOEXEC": syserror;
	    val nolck = _prim "ENOLCK": syserror;
	    val nomem = _prim "ENOMEM": syserror;
	    val nospc = _prim "ENOSPC": syserror;
	    val nosys = _prim "ENOSYS": syserror;
	    val notdir = _prim "ENOTDIR": syserror;
	    val notempty = _prim "ENOTEMPTY": syserror;
	    val notsup = _prim "ENOTSUP": syserror;
	    val notty = _prim "ENOTTY": syserror;
	    val nxio = _prim "ENXIO": syserror;
	    val perm = _prim "EPERM": syserror;
	    val pipe = _prim "EPIPE": syserror;
	    val range = _prim "ERANGE": syserror;
	    val rofs = _prim "EROFS": syserror;
	    val spipe = _prim "ESPIPE": syserror;
	    val srch = _prim "ESRCH": syserror;
	    val toobig = _prim "E2BIG": syserror;
	    val xdev = _prim "EXDEV": syserror;

	    val errorNames =
	       [
		(acces, "acces"),
		(again, "again"),
		(badf, "badf"),
		(badmsg, "badmsg"),
		(busy, "busy"),
		(canceled, "canceled"),
		(child, "child"),
		(deadlk, "deadlk"),
		(dom, "dom"),
		(exist, "exist"),
		(fault, "fault"),
		(fbig, "fbig"),
		(inprogress, "inprogress"),
		(intr, "intr"),
		(inval, "inval"),
		(io, "io"),
		(isdir, "isdir"),
		(loop, "loop"),
		(mfile, "mfile"),
		(mlink, "mlink"),
		(msgsize, "msgsize"),
		(nametoolong, "nametoolong"),
		(nfile, "nfile"),
		(nodev, "nodev"),
		(noent, "noent"),
		(noexec, "noexec"),
		(nolck, "nolck"),
		(nomem, "nomem"),
		(nospc, "nospc"),
		(nosys, "nosys"),
		(notdir, "notdir"),
		(notempty, "notempty"),
		(notsup, "notsup"),
		(notty, "notty"),
		(nxio, "nxio"),
		(perm, "perm"),
		(pipe, "pipe"),
		(range, "range"),
		(rofs, "rofs"),
		(spipe, "spipe"),
		(srch, "srch"),
		(toobig, "toobig"),
		(xdev, "xdev")
		]
	 end
      
      structure FileSys =
	 struct
	    datatype file_desc = datatype file_desc

	    type ino = int
	    type dev = word
	    type uid = uid
	    type gid = gid

	    structure S =
	       struct
		  type mode = word
		  val ifsock = _prim "S_IFSOCK": mode;
		  val ifsock = _prim "S_IFSOCK": mode;
		  val iflnk = _prim "S_IFLNK": mode;
		  val ifreg = _prim "S_IFREG": mode;
		  val ifblk = _prim "S_IFBLK": mode;
		  val ifdir = _prim "S_IFDIR": mode;
		  val ifchr = _prim "S_IFCHR": mode;
		  val ififo = _prim "S_IFIFO": mode;
		  val irwxu = _prim "S_IRWXU": mode;
		  val irusr = _prim "S_IRUSR": mode;
		  val iwusr = _prim "S_IWUSR": mode;
		  val ixusr = _prim "S_IXUSR": mode;
		  val irwxg = _prim "S_IRWXG": mode;
		  val irgrp = _prim "S_IRGRP": mode;
		  val iwgrp = _prim "S_IWGRP": mode;
		  val ixgrp = _prim "S_IXGRP": mode;
		  val irwxo = _prim "S_IRWXO": mode;
		  val iroth = _prim "S_IROTH": mode;
		  val iwoth = _prim "S_IWOTH": mode;
		  val ixoth = _prim "S_IXOTH": mode;
		  val isuid = _prim "S_ISUID": mode;
		  val isgid = _prim "S_ISGID": mode;
	       end

	    structure O =
	       struct
		  type flags = word
		  val append = _prim "O_APPEND": flags;
		  val creat = _prim "O_CREAT": flags;
		  val excl = _prim "O_EXCL": flags;
		  val noctty = _prim "O_NOCTTY": flags;
		  val nonblock = _prim "O_NONBLOCK": flags;
		  val sync = _prim "O_SYNC": flags;
		  val trunc = _prim "O_TRUNC": flags;
                  val text = _prim "O_TEXT": flags;
                  val binary = _prim "O_BINARY": flags;
	       end

	    val o_rdonly = _prim "O_RDONLY": word;
	    val o_wronly = _prim "O_WRONLY": word;
	    val o_rdwr = _prim "O_RDWR": word;
	    val R_OK = _prim "R_OK": word;
	    val W_OK = _prim "W_OK": word;
	    val X_OK = _prim "X_OK": word;
	    val F_OK = _prim "F_OK": word;

	    val properties =
	       [
		(_prim "_PC_LINK_MAX": int;, "LINK_MAX"),
		(_prim "_PC_MAX_CANON": int;, "MAX_CANON"),
		(_prim "_PC_MAX_INPUT": int;, "MAX_INPUT"),
		(_prim "_PC_NAME_MAX": int;, "NAME_MAX"),
		(_prim "_PC_PATH_MAX": int;, "PATH_MAX"),
		(_prim "_PC_PIPE_BUF": int;, "PIPE_BUF"),
		(_prim "_PC_CHOWN_RESTRICTED": int;, "CHOWN_RESTRICTED"),
		(_prim "_PC_NO_TRUNC": int;, "NO_TRUNC"),
		(_prim "_PC_VDISABLE": int;, "VDISABLE")
		]

	    structure Dirent =
	       struct
		  type dirent = pointer

		  val isNull = _prim "MLTON_isNull": dirent -> bool;
		  val name = _prim "MLTON_dirent_name": dirent -> cstring;
	       end
	    
	    structure Dirstream =
	       struct
		  type dirstream = pointer

		  val isNull = _prim "MLTON_isNull": dirstream -> bool;
		  val closedir = _prim "MLTON_closedir": dirstream -> int;
		  val opendir = _prim "MLTON_opendir": nullString -> dirstream;
		  val readdir =
		     _prim "MLTON_readdir": dirstream -> Dirent.dirent;
		  val rewinddir =
		     _prim "MLTON_rewinddir": dirstream -> unit;
	       end

	    structure Stat =
	       struct
		  type stat = pointer

		  val buffer = _prim "(uint)&MLTON_stat": stat;

		  val dev = _prim "MLTON_stat_dev": stat -> dev;
		  val ino = _prim "MLTON_stat_ino": stat -> ino;
		  val mode = _prim "MLTON_stat_mode": stat -> word;
		  val nlink = _prim "MLTON_stat_nlink": stat -> int;
		  val uid = _prim "MLTON_stat_uid": stat -> uid;
		  val gid = _prim "MLTON_stat_gid": stat -> gid;
		  val size = _prim "MLTON_stat_size": stat -> int;
		  val atime = _prim "MLTON_stat_atime": stat -> time;
		  val mtime = _prim "MLTON_stat_mtime": stat -> time;
		  val ctime = _prim "MLTON_stat_ctime": stat -> time;

		  val fstat = _prim "MLTON_fstat": fd * stat -> int;
		  val lstat = _prim "MLTON_lstat": nullString * stat -> int;
		  val stat = _prim "MLTON_stat": nullString * stat -> int;
	       end

	    structure Utimbuf =
	       struct
		  type utimbuf = pointer

		  val buffer = _prim "(uint)&MLTON_utimbuf": utimbuf;
		  val setActime =
		     _prim "MLTON_set_utimbuf_actime"
		     : utimbuf * time -> unit;
		  val setModtime =
		     _prim "MLTON_set_utimbuf_modtime"
		     : utimbuf * time -> unit;
		  val utime = _prim "MLTON_utime": nullString * utimbuf -> int;
	       end

	    val access = _prim "MLTON_access": nullString * word -> int;
	    val chdir = _prim "MLTON_chdir": nullString -> int;
	    val chmod = _prim "MLTON_chmod": nullString * mode -> int;
	    val chown = _prim "MLTON_chown": nullString * uid * gid -> int;
	    val fchmod = _prim "fchmod": fd * mode -> int;
	    val fchown = _prim "fchown": fd * uid * gid -> int;
	    val fpathconf = _prim "pathconf": fd * int -> int;
	    val ftruncate = _prim "MLTON_ftruncate": int * int -> int;
	    val getcwd = _prim "MLTON_getcwd": char array * size -> cstring;
	    val link = _prim "MLTON_link": nullString * nullString -> int;
	    val mkdir = _prim "MLTON_mkdir": nullString * word -> int;
	    val mkfifo = _prim "MLTON_mkfifo": nullString * word -> int;
	    val openn = _prim "MLTON_open": nullString * word * mode -> fd;
	    val pathconf = _prim "MLTON_pathconf": nullString * int -> int;
	    val readlink =
	       _prim "MLTON_readlink": nullString * Word8Array.array * int -> int;
	    val rename = _prim "MLTON_rename": nullString * nullString -> int;
	    val rmdir = _prim "MLTON_rmdir": nullString -> int;
	    val symlink = _prim "MLTON_symlink": nullString * nullString -> int;
	    val umask = _prim "umask": word -> word;
	    val unlink = _prim "MLTON_unlink": nullString -> int;

	    structure ST =
	       struct
		  val isDir = _prim "S_ISDIR": word -> bool;
		  val isChr = _prim "S_ISCHR": word -> bool;
		  val isBlk = _prim "S_ISBLK": word -> bool;
		  val isReg = _prim "S_ISREG": word -> bool;
		  val isFIFO = _prim "S_ISFIFO": word -> bool;
		  val isLink = _prim "S_ISLNK": word -> bool;
		  val isSock = _prim "S_ISSOCK": word -> bool;
	       end
	 end

      structure IO =
	 struct
	    val F_DUPFD = _prim "F_DUPFD": int;
	    val F_GETFD = _prim "F_GETFD": int;
	    val F_SETFD = _prim "F_SETFD": int;
	    val F_GETFL = _prim "F_GETFL": int;
	    val F_SETFL = _prim "F_SETFL": int;
	    val F_GETLK = _prim "F_GETLK": int;
	    val F_SETLK = _prim "F_SETLK": int;
	    val F_RDLCK = _prim "F_RDLCK": int;
	    val F_WRLCK = _prim "F_WRLCK": int;
	    val F_UNLCK = _prim "F_UNLCK": int;
	    val F_SETLKW = _prim "F_SETLKW": int;
	    val F_GETOWN = _prim "F_GETOWN": int;
	    val F_SETOWN = _prim "F_SETOWN": int;
	    val O_ACCMODE = _prim "O_ACCMODE": word;
	    val SEEK_SET = _prim "SEEK_SET": int;
	    val SEEK_CUR = _prim "SEEK_CUR": int;
	    val SEEK_END = _prim "SEEK_END": int;

	    structure FD =
	       struct
		  type flags = word
		  val cloexec = _prim "FD_CLOEXEC": flags;
	       end
	    
	    datatype file_desc = datatype file_desc
	    type pid = pid

	    structure Flock =
	       struct
		  type flock = pointer

		  val buffer = _prim "(uint)&MLTON_flock": flock;

		  val toInt = _prim "castInt": flock -> int;
		     
		  val typ = _prim "MLTON_flock_type": flock -> int;
		  val whence = _prim "MLTON_flock_whence": flock -> int;
		  val start = _prim "MLTON_flock_start": flock -> int;
		  val len = _prim "MLTON_flock_len": flock -> int;
		  val pid = _prim "MLTON_flock_pid": flock -> int;

		  val setType =
		     _prim "MLTON_set_flock_type": flock * int -> unit;
		  val setWhence =
		     _prim "MLTON_set_flock_whence": flock * int -> unit;
		  val setStart =
		     _prim "MLTON_set_flock_start": flock * int -> unit;
		  val setLen =
		     _prim "MLTON_set_flock_len": flock * int -> unit;
		  val setPid =
		     _prim "MLTON_set_flock_pid": flock * int -> unit;
	       end
	    
	    val close = _prim "close": fd -> int;
	    val dup = _prim "dup": fd -> fd;
	    val dup2 = _prim "dup2": fd * fd -> fd;
	    val fcntl2 = _prim "fcntl": fd * int -> int;
	    val fcntl3 = _prim "fcntl": fd * int * int -> int;
	    val fsync = _prim "fsync": fd -> int;
	    val lseek = _prim "lseek": fd * int * int -> int;
	    val pipe = _prim "MLTON_pipe": fd array -> int;
	    val read = _prim "MLTON_read": fd * word8 array * int * size -> ssize;
	    val write =
	       _prim "MLTON_write": fd * word8 vector * int * size -> ssize;
	 end	       

      structure ProcEnv =
	 struct
	    val MLTON_numgroups = _prim "MLTON_numgroups": int;
	    val sysconfNames =
	       [
		(_prim "_SC_ARG_MAX": int;, "ARG_MAX"),
		(_prim "_SC_CHILD_MAX": int;, "CHILD_MAX"),
		(_prim "_SC_CLK_TCK": int;, "CLK_TCK"),
		(_prim "_SC_STREAM_MAX": int;, "STREAM_MAX"),
		(_prim "_SC_TZNAME_MAX": int;, "TZNAME_MAX"),
		(_prim "_SC_OPEN_MAX": int;, "OPEN_MAX"),
		(_prim "_SC_JOB_CONTROL": int;, "JOB_CONTROL"),
		(_prim "_SC_SAVED_IDS": int;, "SAVED_IDS"),
		(_prim "_SC_VERSION": int;, "VERSION"),
		(_prim "_SC_BC_BASE_MAX": int;, "BC_BASE_MAX"),
		(_prim "_SC_BC_DIM_MAX": int;, "BC_DIM_MAX"),
		(_prim "_SC_BC_SCALE_MAX": int;, "BC_SCALE_MAX"),
		(_prim "_SC_BC_STRING_MAX": int;, "BC_STRING_MAX"),
		(_prim "_SC_COLL_WEIGHTS_MAX": int;, "COLL_WEIGHTS_MAX"),
		(_prim "_SC_EXPR_NEST_MAX": int;, "EXPR_NEST_MAX"),
		(_prim "_SC_LINE_MAX": int;, "LINE_MAX"),
		(_prim "_SC_RE_DUP_MAX": int;, "RE_DUP_MAX"),
		(_prim "_SC_2_VERSION": int;, "2_VERSION"),
		(_prim "_SC_2_FORT_DEV": int;, "2_FORT_DEV"),
		(_prim "_SC_2_FORT_RUN": int;, "2_FORT_RUN"),
		(_prim "_SC_2_SW_DEV": int;, "2_SW_DEV")
		]
	       
	    type pid = pid
	    type gid = gid
	    type uid = uid
	    datatype file_desc = datatype file_desc

	    val getpid = _prim "getpid": unit -> pid;
	    val getppid = _prim "getppid": unit -> pid;
	    val getuid = _prim "getuid": unit -> uid;
	    val geteuid = _prim "geteuid": unit -> uid;
	    val getgid = _prim "getgid": unit -> gid;
	    val getegid = _prim "getegid": unit -> gid;
	    val setuid = _prim "setuid": uid -> unit;
	    val setgid = _prim "setgid": gid -> unit;
	    val getgroups = _prim "MLTON_getgroups": gid array -> int;
	    val getlogin = _prim "MLTON_getlogin": unit -> cstring;
	    val getpgrp = _prim "getpgrp": unit -> pid;
	    val setsid = _prim "setsid": unit -> pid;
	    val setpgid = _prim "setpgid": pid * gid -> unit;

	    structure Uname =
	       struct
		  type uname = pointer

		  val buffer = _prim "(uint)&MLTON_utsname": uname;
		     
		  val uname = _prim "MLTON_uname": uname -> int;
		     
		  val sysname =
		     _prim "MLTON_uname_sysname": uname -> cstring;
		  val nodename =
		     _prim "MLTON_uname_nodename": uname -> cstring;
		  val release =
		     _prim "MLTON_uname_release": uname -> cstring;
		  val version =
		     _prim "MLTON_uname_version": uname -> cstring;
		  val machine =
		     _prim "MLTON_uname_machine": uname -> cstring;
	       end

	    structure Tms =
	       struct
		  type tms = pointer

		  val buffer = _prim "(uint)&MLTON_tms": tms;

		  val utime = _prim "MLTON_tms_utime": tms -> int;
		  val stime = _prim "MLTON_tms_stime": tms -> int;
		  val cutime = _prim "MLTON_tms_cutime": tms -> int;
		  val cstime = _prim "MLTON_tms_cstime": tms -> int;
	       end

	    val ctermid = _prim "MLTON_ctermid": unit -> cstring;
	    val environ = _prim "mltonState.environ": cstringArray;
	    val getenv = _prim "MLTON_getenv": nullString -> cstring;
	    val isatty = _prim "isatty": fd -> bool;
	    val sysconf = _prim "sysconf": int -> int;
	    val times = _prim "MLTON_times": Tms.tms -> int;
	    val ttyname = _prim "MLTON_ttyname": fd -> cstring;
	 end 

      structure Process =
	 struct
	    val wnohang = _prim "WNOHANG": word;
	    structure W =
	       struct
		  type flags = word
		  val untraced = _prim "WUNTRACED": flags;
	       end
	    
	    type pid = pid
	    type status = int

	    val alarm = _prim "alarm": int -> int;
	    val exec =
	       _prim "MLTON_exec": nullString * nullString array -> int;
	    val exece =
	       _prim "MLTON_exece"
	       : nullString * nullString array * nullString array -> int;
	    val execp =
	       _prim "MLTON_execp": nullString * nullString array -> int;
	    val exit = _prim "exit": int -> unit;
	    val fork = _prim "fork": unit -> pid;
	    val kill = _prim "kill": pid * signal -> int;
	    val pause = _prim "pause": unit -> int;
	    val sleep = _prim "sleep": int -> int;
	    val waitpid =
	       _prim "MLTON_waitpid": pid * status ref * int -> pid;

	    val ifExited = _prim "WIFEXITED": status -> bool;
	    val exitStatus = _prim "WEXITSTATUS": status -> int;
	    val ifSignaled = _prim "WIFSIGNALED": status -> bool;
	    val termSig = _prim "WTERMSIG": status -> signal;
	    val ifStopped = _prim "WIFSTOPPED": status -> bool;
	    val stopSig = _prim "WSTOPSIG": status -> signal;
	 end
      
      structure Signal =
	 struct
	    type signal = signal

	    type how = int
	    val block = _prim "SIG_BLOCK": how;
	    val unblock = _prim "SIG_UNBLOCK": how;
	    val setmask = _prim "SIG_SETMASK": how;

	    type sigset = word ref
	       
	    type signum = int
	    val sigemptyset = _prim "MLTON_sigemptyset": sigset -> int;
	    val sigfillset = _prim "MLTON_sigfillset": sigset -> int;
	    val sigaddset = _prim "MLTON_sigaddset": sigset * signum -> int;
	    val sigdelset = _prim "MLTON_sigdelset": sigset * signum -> int;
	    val sigismember = _prim "MLTON_sigismember": sigset * signum -> int;
	    val sigpending = _prim "MLTON_sigpending": sigset -> int;
	    val sigprocmask = _prim "MLTON_sigprocmask": how * sigset -> int;
	    val sigsuspend = _prim "MLTON_sigsuspend": sigset -> int;

	    val abrt = _prim "SIGABRT": signal;
	    val alrm = _prim "SIGALRM": signal;
	    val bus = _prim " SIGBUS": signal;
	    val chld = _prim "SIGCHLD": signal;
	    val cont = _prim "SIGCONT": signal;
	    val fpe = _prim "SIGFPE": signal;
	    val hup = _prim "SIGHUP": signal;
	    val ill = _prim "SIGILL": signal;
	    val int = _prim "SIGINT": signal;
	    val kill = _prim "SIGKILL": signal;
	    val pipe = _prim "SIGPIPE": signal;
	    val quit = _prim "SIGQUIT": signal;
	    val segv = _prim "SIGSEGV": signal;
	    val stop = _prim "SIGSTOP": signal;
	    val term = _prim "SIGTERM": signal;
	    val tstp = _prim "SIGTSTP": signal;
	    val ttin = _prim "SIGTTIN": signal;
	    val ttou = _prim "SIGTTOU": signal;
	    val usr1 = _prim "SIGUSR1": signal;
	    val usr2 = _prim "SIGUSR2": signal;
	 end
      
      structure SysDB =
	 struct
	    type gid = gid
	    type uid = uid

	    structure Passwd =
	       struct
		  type passwd = pointer

		  val isNull = _prim "MLTON_isNull": passwd -> bool;
		  val name = _prim "MLTON_passwd_name": passwd -> cstring;
		  val uid = _prim "MLTON_passwd_uid": passwd -> uid;
		  val gid = _prim "MLTON_passwd_gid": passwd -> gid;
		  val dir = _prim "MLTON_passwd_dir": passwd -> cstring;
		  val shell = _prim "MLTON_passwd_shell": passwd -> cstring;
	       end

	    val getpwnam = _prim "MLTON_getpwnam": nullString -> Passwd.passwd;
	    val getpwuid = _prim "MLTON_getpwuid": uid -> Passwd.passwd;

	    structure Group =
	       struct
		  type group = pointer

		  val isNull = _prim "MLTON_isNull": group -> bool;
		  val name = _prim "MLTON_group_name": group -> cstring;
		  val gid = _prim "MLTON_group_gid": group -> gid;
		  val mem = _prim "MLTON_group_mem": group -> C.CSS.css;
	       end

	    val getgrgid = _prim "MLTON_getgrgid": gid -> Group.group;
	    val getgrnam = _prim "MLTON_getgrnam": nullString -> Group.group;
	 end

      structure TTY =
	 struct
	    type speed = word
	    val b0 = _prim "B0": speed;
	    val b110 = _prim "B110": speed;
	    val b1200 = _prim "B1200": speed;
	    val b134 = _prim "B134": speed;
	    val b150 = _prim "B150": speed;
	    val b1800 = _prim "B1800": speed;
	    val b19200 = _prim "B19200": speed;
	    val b200 = _prim "B200": speed;
	    val b2400 = _prim "B2400": speed;
	    val b300 = _prim "B300": speed;
	    val b38400 = _prim "B38400": speed;
	    val b4800 = _prim "B4800": speed;
	    val b50 = _prim "B50": speed;
	    val b600 = _prim "B600": speed;
	    val b75 = _prim "B75": speed;
	    val b9600 = _prim "B9600": speed;
	       
	    type pid = pid
	    datatype file_desc = datatype file_desc

	    structure V =
	       struct
		  val eof = _prim "VEOF": int;
		  val eol = _prim "VEOL": int;
		  val erase = _prim "VERASE": int;
		  val intr = _prim "VINTR": int;
		  val kill = _prim "VKILL": int;
		  val min = _prim "VMIN": int;
		  val nccs = _prim "NCCS": int;
		  val quit = _prim "VQUIT": int;
		  val start = _prim "VSTART": int;
		  val stop = _prim "VSTOP": int;
		  val susp = _prim "VSUSP": int;
		  val time = _prim "VTIME": int;
	       end

	    structure I =
	       struct
		  type flags = word
		  val brkint = _prim "BRKINT": flags;
		  val icrnl = _prim "ICRNL": flags;
		  val ignbrk = _prim "IGNBRK": flags;
		  val igncr = _prim "IGNCR": flags;
		  val ignpar = _prim "IGNPAR": flags;
		  val inlcr = _prim "INLCR": flags;
		  val inpck = _prim "INPCK": flags;
		  val istrip = _prim "ISTRIP": flags;
		  val ixoff = _prim "IXOFF": flags;
		  val ixon = _prim "IXON": flags;
		  val parmrk = _prim "PARMRK": flags;
	       end

	    structure O =
	       struct
		  type flags = word
		  val opost = _prim "OPOST": flags;
	       end

	    structure C =
	       struct
		  type flags = word
		  val clocal = _prim "CLOCAL": flags;
		  val cread = _prim "CREAD": flags;
		  val cs5 = _prim "CS5": flags;
		  val cs6 = _prim "CS6": flags;
		  val cs7 = _prim "CS7": flags;
		  val cs8 = _prim "CS8": flags;
		  val csize = _prim "CSIZE": flags;
		  val cstopb = _prim "CSTOPB": flags;
		  val hupcl = _prim "HUPCL": flags;
		  val parenb = _prim "PARENB": flags;
		  val parodd = _prim "PARODD": flags;
	       end

	    structure L =
	       struct
		  type flags = word
		  val echo = _prim "ECHO": flags;
		  val echoe = _prim "ECHOE": flags;
		  val echok = _prim "ECHOK": flags;
		  val echonl = _prim "ECHONL": flags;
		  val icanon = _prim "ICANON": flags;
		  val iexten = _prim "IEXTEN": flags;
		  val isig = _prim "ISIG": flags;
		  val noflsh = _prim "NOFLSH": flags;
		  val tostop = _prim "TOSTOP": flags;
	       end

	    structure TC =
	       struct
		  type set_action = int

		  val sadrain = _prim "TCSADRAIN": set_action;
		  val saflush = _prim "TCSAFLUSH": set_action;
		  val sanow = _prim "TCSANOW": set_action;

		  type flow_action = int

		  val ion = _prim "TCION": flow_action;
		  val ioff = _prim "TCIOFF": flow_action;
		  val ooff = _prim "TCOOFF": flow_action;
		  val oon = _prim "TCOON": flow_action;

		  type queue_sel = int

		  val iflush = _prim "TCIFLUSH": queue_sel;
		  val ioflush = _prim "TCIOFLUSH": queue_sel;
		  val oflush = _prim "TCOFLUSH": queue_sel;
	       end		  

	    structure Termios =
	       struct
		  type t = pointer
		  type flag = word

		  val buffer = _prim "(uint)&MLTON_termios": t;
		  val iflag = _prim "MLTON_termios_iflag": t -> flag;
		  val oflag = _prim "MLTON_termios_oflag": t -> flag;
		  val cflag = _prim "MLTON_termios_cflag": t -> flag;
		  val lflag = _prim "MLTON_termios_lflag": t -> flag;
		  val cc = _prim "MLTON_termios_cc": t -> Primitive.C.CS.cs;
		  val ospeed =
		     _prim "MLTON_cfgetospeed": t -> speed;
		  val ispeed =
		     _prim "MLTON_cfgetispeed": t -> speed;

		  val setiflag =
		     _prim "MLTON_set_termios_iflag": t * flag -> unit;
		  val setoflag =
		     _prim "MLTON_set_termios_oflag": t * flag -> unit;
		  val setcflag =
		     _prim "MLTON_set_termios_cflag": t * flag -> unit;
		  val setlflag =
		     _prim "MLTON_set_termios_lflag": t * flag -> unit;
		  val setospeed =
		     _prim "MLTON_cfsetospeed": t * speed -> int;
		  val setispeed =
		     _prim "MLTON_cfsetispeed": t * speed -> int;
	       end

	    val getattr =
	       _prim "MLTON_tcgetattr": fd * Termios.t -> int;
	    val setattr =
	       _prim "MLTON_tcsetattr"
	       : fd * TC.set_action * Termios.t -> int;
	    val sendbreak = _prim "tcsendbreak": fd * int -> int;
	    val drain = _prim "tcdrain": fd -> int;
	    val flush = _prim "tcflush": fd * TC.queue_sel -> int;
	    val flow = _prim "tcflow": fd * TC.flow_action -> int;

	    val getpgrp = _prim "tcgetpgrp": fd -> pid;
	    val setpgrp = _prim "tcsetpgrp": fd * pid -> int;
	 end
   end