The Standard ML Basis Library


The Posix.TTY structure


Synopsis

signature POSIX_TTY
structure TTY : POSIX_TTY

The structure Posix.TTY specifies a model of a general terminal interface, as described in Section 7 of the POSIX standard 1003.1,1996[CITE].


Interface

eqtype pid
eqtype file_desc

structure V : sig
    val eof   : int
    val eol   : int
    val erase : int
    val intr  : int
    val kill  : int
    val min   : int
    val quit  : int
    val susp  : int
    val time  : int
    val start : int
    val stop  : int
    val nccs : int
    type cc
    val cc : (int * char) list -> cc
    val update : cc * (int * char) list -> cc
    val sub : cc * int -> char
  end

structure I : sig
    include BIT_FLAGS
    val brkint : flags
    val icrnl  : flags
    val ignbrk : flags
    val igncr  : flags
    val ignpar : flags
    val inlcr  : flags
    val inpck  : flags
    val istrip : flags
    val ixoff  : flags
    val ixon   : flags
    val parmrk : flags
  end

structure O : sig
    include BIT_FLAGS
    val opost : flags
  end

structure C : sig
    include BIT_FLAGS
    val clocal : flags
    val cread  : flags
    val cs5    : flags
    val cs6    : flags
    val cs7    : flags
    val cs8    : flags
    val csize  : flags
    val cstopb : flags
    val hupcl  : flags
    val parenb : flags
    val parodd : flags
  end

structure L : sig
    include BIT_FLAGS
    val echo   : flags
    val echoe  : flags
    val echok  : flags
    val echonl : flags
    val icanon : flags
    val iexten : flags
    val isig   : flags
    val noflsh : flags
    val tostop : flags
  end

eqtype speed

val compareSpeed : speed * speed -> order
val speedToWord : speed -> SysWord.word
val wordToSpeed : SysWord.word -> speed

val b0   : speed
val b50  : speed
val b75  : speed
val b110 : speed
val b134 : speed
val b150 : speed
val b200 : speed
val b300 : speed
val b600 : speed
val b1200 : speed
val b1800 : speed
val b2400 : speed
val b4800 : speed
val b9600 : speed
val b19200 : speed
val b38400 : speed

type termios

val termios : {
                  iflag : I.flags,
                  oflag : O.flags,
                  cflag : C.flags,
                  lflag : L.flags,
                  cc : V.cc,
                  ispeed : speed,
                  ospeed : speed
                } -> termios
val fieldsOf : termios
                 -> {
                   iflag : I.flags,
                   oflag : O.flags,
                   cflag : C.flags,
                   lflag : L.flags,
                   cc : V.cc,
                   ispeed : speed,
                   ospeed : speed
                 }
val getiflag : termios -> I.flags
val getoflag : termios -> O.flags
val getcflag : termios -> C.flags
val getlflag : termios -> L.flags
val getcc    : termios -> V.cc

structure CF : sig
    val getospeed : termios -> speed
    val getispeed : termios -> speed
    val setospeed : termios * speed -> termios
    val setispeed : termios * speed -> termios
  end

structure TC : sig
    eqtype set_action
    
    val sanow   : set_action
    val sadrain : set_action
    val saflush : set_action
    
    eqtype flow_action
    
    val ooff : flow_action
    val oon  : flow_action
    val ioff : flow_action
    val ion  : flow_action
    
    eqtype queue_sel
    
    val iflush  : queue_sel
    val oflush  : queue_sel
    val ioflush : queue_sel
    
    val getattr : file_desc -> termios
    val setattr : file_desc * set_action * termios -> unit
    val sendbreak : file_desc * int -> unit
    val drain : file_desc -> unit
    val flush : file_desc * queue_sel -> unit
    val flow : file_desc * flow_action -> unit
    val getpgrp : file_desc -> pid
    val setpgrp : file_desc * pid -> unit
  end

Description

eqtype pid
A process identifier.

eqtype file_desc
An open file descriptor.

structure V
The V substructure provides means for specifying the special control characters.

val eof : int
val eol : int
val erase : int
val intr : int
val kill : int
val min : int
val quit : int
val susp : int
val time : int
val start : int
val stop : int
Indices for the special control characters EOF, EOL, ERASE, INTR, KILL, MIN, QUIT, SUSP, TIME, START, and STOP, respectively. These are the indices used in the functions cc and sub.

val nccs : int
The total number of special characters. Thus, valid indices range from 0 to nccs-1.

type cc
A vector of special control characters used by the device driver.

cc l
creates a value of type cc, mapping an index to its paired character. Unspecified indices are associated with #"\000". For example, to have the character #"\^D" (control-D) serve as the EOF (end-of-file) character, one would use
cc [(V.eof, #"\^D")]
to create a cc value, embed this in a termios type, and invoke TC.setattr.

update (cs, l)
returns a copy of cs, but with the new mappings specified by l overwriting the original mappings.

sub (cs, i)
returns the special control character associated in cs with the index i. It raises Subscript if i is negative or i >= nccs.

structure I
The I substructure contains flags for specifying input control. The following table provides a brief description of the flags.
Flag name Description
brkint Signal interrupt on break.
icrnl Map CR (#"\^M") to NL (#"\n") on input.
ignbrk Ignore a break condition.
igncr Ignore CR characters.
ignpar Ignore characters with parity errors.
inlcr Map NL to CR on input.
inpck Enable input parity check.
istrip Strip the eighth bit of a byte.
ixoff Enable start/stop input control.
ixon Enable start/stop output control.
parmrk Mark parity errors.



structure O
The O substructure contains flags for specifying output control.

val opost : flags
Perform output processing.

structure C
The C substructure contains flags for specifying basic terminal hardware control. The following table provides a brief description of the flags.
Flag name Description
clocal Ignore modem status lines.
cread Enable the receiver.
csize Mask for the number of bits per byte used for both transmission and reception. This is the union of cs5, cs6, cs7, and cs8.
cs5 5 bits per byte.
cs6 6 bits per byte.
cs7 7 bits per byte.
cs8 8 bits per byte.
cstopb Specifies sending two stop bits rather than one.
hupcl Hang up the modem connection when the last process with the port open closes it.
parenb Enable parity generation and detection.
parodd Use odd parity rather than even if parenb is set.



structure L
The L substructure contains flags for specifying various local control modes. The following table provides a brief description of the flags.
Flag name Description
echo Echo input characters back to the terminal.
echoe Echo the ERASE character on backspace in canonical mode.
echok Echo the KILL character in canonical mode.
echonl In canonical mode, echo a NL character even if echo is not set.
icanon Set canonical mode, enabling erase and kill processing, and providing line-based input.
iexten Enable extended functions.
isig Enable input characters to be mapped to signals.
noflsh Disable the normal input and output flushing connected with the INTR, QUIT, and SUSP characters. (See the Posix.TTY.V substructure.)
tostop Send Posix.Signal.ttou for background output.



eqtype speed
Terminal input and output baud rates.

compareSpeed (sp, sp')
returns LESS, EQUAL, or GREATER when the baud rate sp is less than, equal to, or greater than that of sp', respectively.

val speedToWord : speed -> SysWord.word
val wordToSpeed : SysWord.word -> speed
These converts between a speed value and its underlying word representation. No checking is performed by wordToSpeed to ensure the resulting value corresponds to an allowed speed in the given system.

type termios
The attributes associated with a terminal. It acts as an abstract representation of the record used as the argument to the termios function.

val termios : {
                  iflag : I.flags,
                  oflag : O.flags,
                  cflag : C.flags,
                  lflag : L.flags,
                  cc : V.cc,
                  ispeed : speed,
                  ospeed : speed
                } -> termios
This creates a termios value using the given flags, special characters, and speeds.

val fieldsOf : termios
                 -> {
                   iflag : I.flags,
                   oflag : O.flags,
                   cflag : C.flags,
                   lflag : L.flags,
                   cc : V.cc,
                   ispeed : speed,
                   ospeed : speed
                 }
This returns a concrete representation of a termios value.

val getiflag : termios -> I.flags
val getoflag : termios -> O.flags
val getcflag : termios -> C.flags
val getlflag : termios -> L.flags
val getcc : termios -> V.cc
These are the obvious projection functions from a termios value to its constituent fields.

structure CF
The CF substructure contains functions for getting and setting the input and output baud rates in a termios value.

val getospeed : termios -> speed
val getispeed : termios -> speed
These return the output and input baud rates, respectively, of the argument.

setospeed (t, speed)
setispeed (t, speed)
These return a copy of t, but with the output (input) speed set to speed.

structure TC
The TC substructure contains various types and functions used for handling terminal line control.

eqtype set_action
Values of this type specify the behavior of the setattr function.

val sanow : set_action
val sadrain : set_action
val saflush : set_action
sanow
Changes occur immediately.
sadrain
Changes occur after all output is transmitted.
saflush
Changes occur after all output is transmitted and after all received but unread input is discarded.


eqtype flow_action
Values of this type specify the behavior of the flow function.

val ooff : flow_action
val oon : flow_action
val ioff : flow_action
val ion : flow_action
ooff
Causes suspension of output.
oon
Restarts suspended output.
ioff
Causes the transmission of a STOP character to the terminal device, to stop it from transmitting data.
ion
Causes the transmission of a START character to the terminal device, to restart it transmitting data.


eqtype queue_sel
Values of this type specify the behavior of the flush function.

val iflush : queue_sel
val oflush : queue_sel
val ioflush : queue_sel
iflush
Causes all data received but not read to be flushed.
oflush
Causes all data written but not transmitted to be flushed.
ioflush
Discards all data written but not transmitted, or received but not read.


getattr fd
gets the attributes of the terminal associated with file descriptor fd.

setattr (fd, action, termios)
sets the attributes of the terminal associated with file descriptor fd as specified in termios. When the change occurs is specified by action.

sendbreak (fd, t)
causes the transmission of a sequence of zero-valued bits to be sent, if the associated terminal is using asynchronous serial data transmission. If t is 0, this will send zero-valued bits for at least a quarter second, and no more than half a second. If t is not zero, zero-valued bits are transmitted for an implementation-defined period of time.

drain fd
waits for all output written on fd to be transmitted.

flush (fd, qs)
discards any data written but not transmitted, or received but not read, depending on the value of qs.

flow (fd, action)
suspends and restarts transmission or reception of data, depending on the value of action.

getpgrp fd
returns the process group ID of the foreground process group associated with the terminal attached to fd.

setpgrp (fd, pid)
sets the foreground process group ID associated with fd to pid.

See Also

BIT_FLAGS, Posix, Posix.Error, Posix.FileSys, Posix.IO, Posix.Process

Discussion

The values of type speed defined in this structure specify the standard baud rates with the obvious correspondence, i.e., b1200 is 1200 baud, b9600 is 9600 baud, etc. The value b0 indicates ``hang up.''


[ Top | Parent | Contents | Index | Root ]

Generated April 12, 2004
Last Modified July 1, 2002
Comments to John Reppy.


This document may be distributed freely over the internet as long as the copyright notice and license terms below are prominently displayed within every machine-readable copy.

Copyright © 2004 AT&T and Lucent Technologies. All rights reserved.

Permission is granted for internet users to make one paper copy for their own personal use. Further hardcopy reproduction is strictly prohibited. Permission to distribute the HTML document electronically on any medium other than the internet must be requested from the copyright holders by contacting the editors. Printed versions of the SML Basis Manual are available from Cambridge University Press. To order, please visit www.cup.org (North America) or www.cup.cam.ac.uk (outside North America).