diff options
Diffstat (limited to 'sys/fio/zfiott.x')
| -rw-r--r-- | sys/fio/zfiott.x | 1256 |
1 files changed, 1256 insertions, 0 deletions
diff --git a/sys/fio/zfiott.x b/sys/fio/zfiott.x new file mode 100644 index 00000000..ec7af7e8 --- /dev/null +++ b/sys/fio/zfiott.x @@ -0,0 +1,1256 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <knet.h> +include <ttset.h> +include <ctype.h> +include <chars.h> +include <fio.h> + +# ZFIOTT -- Logical device driver for terminals. This VOS level driver +# implements various software terminal options as a transformation on the +# data stream to the hardware terminal driver "os$zfioty.c". In particular, +# the TT driver can transform input from a monocase terminal into the mixed +# case input required by IRAF, allowing IRAF to be used with old monocase +# terminals, and allowing the user to lock a dual case terminal into upper +# case if desired. The driver can also log i/o to a file, log the input +# or output streams to separate files, or take input from an input logfile +# (`playback' the command input in a file). + +define HELP "\ +\n\r[space or return to continue, g to turn verify off, q to quit]" + +define CONTINUE ' ' # execute command from logfile +define CONTINUE_ALT '\r' # alternative char to continue +define QUIT 'q' # terminate playback mode +define GO 'g' # continue with verify disabled +define CTRLCHAR '^' # used for shift escape functions +define SHIFTLOCK '+' # ^+ +define SHIFTOFF '-' # ^- +define BEGINCOM '{' # \{ comment \} +define ENDCOM '}' # \{ comment \} + +define RMARGIN 75 # for spoolfile output +define DONTCARE 2 # something other than YES or NO +define PBDELAY 500 # default delay in playback mode (msec) +define SZ_LOGLINE 4096 # max chars in a logfile record +define SZ_DEVNAME 20 # max size termcap/graphcap device name + +define IOFILE "home$ttyio.log" +define INFILE "home$ttyin.log" +define OUTFILE "home$ttyout.log" +define PBFILE "home$ttyin.log" + + +# ZGETTT -- Get a line of text from a terminal. Map the input to lower case +# if indicated, and not in raw mode. + +procedure zgettt (fd, buf, maxch, status) + +int fd # input file +char buf[ARB] # output buffer +int maxch # max chars out +int status # actual chars out + +pointer sp, logbuf +int nchars, ch, i +int ztt_lowercase(), ztt_query(), gstrcpy(), and() +include "zfiott.com" +define nextline_ 91 +define again_ 92 + +begin + # Set raw mode if reading a single character. + if (maxch == 1) + tty_rawmode = true + + if (tty_playback && !tty_passthru) { + # Read from the command input spoolfile. + + if (tty_inbuf[tty_ip] == EOS) { + call smark (sp) + call salloc (logbuf, SZ_LOGLINE, TY_CHAR) +nextline_ + call ztt_getlog (tty_pbinchan, Memc[logbuf], SZ_LOGLINE, nchars) + + if (nchars == 1 && Memc[logbuf] == EOFCHAR) { + call ztt_ttyput ("[EOF]\n") + status = 0 + + } else if (nchars > 0) { + # Process any \{ ... \} sequences in the line from the + # logfile, leave 'status' chars of data text in tty_inbuf. + + if (ztt_query (Memc[logbuf], nchars, + tty_inbuf, SZ_LINE, status) == QUIT) { + + # User commands us to quit. + tty_inbuf[1] = EOS + tty_ip = 1 + status = 0 + + } else { + # Copy data text to tty_inbuf. + tty_inbuf[status+1] = EOS + status = gstrcpy (tty_inbuf, buf, maxch) + tty_ip = status + 1 + + # If there was no data on the line but we get here, + # then the line must have been all control directive, + # so go fetch another line from the logfile. + + if (status == 0) + goto nextline_ + } + } else + status = nchars + + call sfree (sp) + + } else { + status = gstrcpy (tty_inbuf[tty_ip], buf, maxch) + tty_ip = tty_ip + status + if (!tty_verify || tty_rawmode) + call zwmsec (tty_delay) + } + + # Terminate playback if there is the read returns zero chars, + # unless this was due to a programmed EOF in the data stream. + + if (status <= 0 && Memc[logbuf] != EOFCHAR) { + call ztt_playback (NO) + call ztt_ttyput ("[playback mode terminated]\n") + buf[1] = '\n' + status = 1 + } + + } else { + # Read from the terminal. +again_ call zgetty (fd, buf, maxch, status) + + if (status > 0) { + # Some terminals set the parity bit, which may not be masked + # by the OS terminal driver in raw mode. Make sure that the + # parity bits are cleared. + + if (tty_rawmode) + do i = 1, status { + ch = buf[i] + buf[i] = and (ch, 177B) + } + + # Filter the input if a filter has been posted and the filter + # key is seen as the first character of the input data block. + # The filter edits the input buffer and returns the number of + # input characters left in the buffer after applying the filter. + + if (tty_filter != 0) + if (buf[1] == tty_filter_key) { + call zcall4 (tty_filter, fd, buf, maxch, status) + if (status == 0) + goto again_ + } + } + } + + # Log the input string if input logging is in effect. + if (tty_login && !tty_passthru) { + if (status <= 0) + call ztt_putlog (tty_inlogchan, "\032", 1) + else + call ztt_putlog (tty_inlogchan, buf, status) + } + + # If UCASE mode in set and not in raw mode, map the input string to + # lower case. + + if ((tty_ucasein || tty_ucaseout) && status > 0) + if (!tty_rawmode && tty_ucasein) + status = ztt_lowercase (buf, buf, status) +end + + +# ZPUTTT -- Put "nchars" characters into the text file "fd". Map the output +# to upper case if so indicated. Watch for the RAWOFF control string, used +# to turn raw mode off. + +procedure zputtt (fd, buf, nchars, status) + +int fd # file to be written to +char buf[ARB] # data to be output +int nchars # nchars to write to file +int status # return status + +int ch +pointer sp, obuf +bool ctrlstr +int strncmp() +include "zfiott.com" +define noucase_ 91 + +begin + # Do not map the raw-mode-off control sequence to upper case. + ctrlstr = false + if (tty_rawmode) + if (nchars == LEN_RAWCMD && buf[1] == ESC) + if (strncmp (buf, RAWOFF, LEN_RAWCMD) == 0) { + ctrlstr = true + tty_rawmode = false + } else if (strncmp (buf, RAWON, LEN_RAWCMD) == 0) { + ctrlstr = true + tty_rawmode = true + } + + if (tty_ucaseout) { + # If not control string and raw mode is not in effect, map the + # string to upper case and output it. Do not map escape or control + # sequences, i.e., any string which begins with a control character. + + if (!ctrlstr && !tty_rawmode) { + ch = buf[1] + if (ch < BLANK) + if (ch != HT && ch != LF && ch != FF && ch != CR) + goto noucase_ + + call smark (sp) + call salloc (obuf, SZ_LINE, TY_CHAR) + + call ztt_uppercase (buf, Memc[obuf], nchars) + call zputty (fd, Memc[obuf], nchars, status) + + if (tty_logout && !tty_passthru) + call ztt_putlog (tty_outlogchan, Memc[obuf], nchars) + + call sfree (sp) + return + } + } +noucase_ + call zputty (fd, buf, nchars, status) + if (tty_logout && !tty_passthru) + call ztt_putlog (tty_outlogchan, buf, nchars) +end + + +# ZTT_LOGIO -- Enable or disable logging of terminal i/o in a file. Logging +# is used for debug purposes but may also be used to keep a complete record +# of a terminal session. + +procedure ztt_logio (inflag, outflag) + +int inflag # log input stream (YES|NO|DONTCARE) +int outflag # log output stream (YES|NO|DONTCARE) + +int status +pointer sp, osfn, fname +string openerr "cannot open file " +include "zfiott.com" + +begin + call smark (sp) + call salloc (fname, SZ_PATHNAME, TY_CHAR) + call salloc (osfn, SZ_PATHNAME, TY_CHAR) + + # Enable/disable logging of the input stream. + if (inflag == YES) { + if (tty_login) { + call zclstx (tty_inlogchan, status) + tty_inlogchan = NULL + tty_login = false + } + + if (tty_logio) + call strcpy (tty_iofile, Memc[fname], SZ_PATHNAME) + else + call strcpy (tty_infile, Memc[fname], SZ_PATHNAME) + + ifnoerr (call fmapfn (Memc[fname], Memc[osfn], SZ_PATHNAME)) { + call zopntx (Memc[osfn], APPEND, tty_inlogchan) + tty_login = (tty_inlogchan != ERR) + } + + if (tty_login) + call ztt_logdev (tty_inlogchan) + else { + call ztt_ttyput (openerr) + call ztt_ttyput (Memc[fname]) + call ztt_ttyput ("\n") + } + + } else if (inflag == NO && tty_login) { + call zclstx (tty_inlogchan, status) + tty_inlogchan = NULL + tty_login = false + if (tty_logio) { + tty_logout = false + tty_logio = false + } + } + + # If LOGIO mode is in effect, set the output logfile to the same + # as the input logfile, otherwise open the output logfile. + + if (tty_logio && tty_login) { + tty_logout = true + tty_outlogchan = tty_inlogchan + + } else if (outflag == YES) { + if (tty_logout) { + call zclstx (tty_outlogchan, status) + tty_outlogchan = NULL + tty_logout = false + } + + ifnoerr (call fmapfn (tty_outfile, Memc[osfn], SZ_PATHNAME)) { + call zopntx (Memc[osfn], APPEND, tty_outlogchan) + tty_logout = (tty_outlogchan != ERR) + } + + if (tty_logout) + call ztt_logdev (tty_outlogchan) + else { + call ztt_ttyput (openerr) + call ztt_ttyput (tty_outfile) + call ztt_ttyput ("\n") + } + + } else if (outflag == NO && tty_logout) { + call zclstx (tty_outlogchan, status) + tty_outlogchan = NULL + tty_logout = false + } + + call sfree (sp) +end + + +# ZTT_PLAYBACK -- Enable or disable playback mode. When playback mode is +# in effect command input is redirected to a tty logfile rather than to the +# terminal. Successive commands are read from the logfile and echoed on +# the terminal. If `verify' mode playback is enabled the user must then +# tap the space bar or CR to continue, at which time the line of text is +# returned to the calling program. Playback mode terminates when EOF is +# seen on the input file, or when the user types `q' in response to the +# verify query. + +procedure ztt_playback (flag) + +int flag # YES to enable playback, NO to disable + +int status +pointer sp, osfn +extern ztt_pboff() +string openerr "cannot open file " +include "zfiott.com" + +begin + call smark (sp) + call salloc (osfn, SZ_PATHNAME, TY_CHAR) + + if (flag == YES) { + # If we try to turn on playback mode while in login mode, log + # the command but do not interrupt login mode or try to reopen + # the ttyin.log file. The logged `stty playback' command will + # cause a (possibly infinite) loop when the logfile is later + # played back. + + if (tty_login) { + call ztt_ttyput ("[command logged but not executed]\n") + call sfree (sp) + return + } + + # Clear playback mode if already in effect. + if (tty_playback) { + call zclstx (tty_pbinchan, status) + tty_pbinchan = NULL + tty_playback = false + } + + # Open login file. + ifnoerr (call fmapfn (tty_pbfile, Memc[osfn], SZ_PATHNAME)) { + call zopntx (Memc[osfn], READ_ONLY, tty_pbinchan) + tty_playback = (tty_pbinchan != ERR) + } + + # Setup to clear playback mode if error occurs during playback. + if (tty_playback) { + call onerror (ztt_pboff) + tty_tdevice[1] = EOS + tty_gdevice[1] = EOS + } else { + call ztt_ttyput (openerr) + call ztt_ttyput (tty_pbfile) + call ztt_ttyput ("\n") + } + + } else if (flag == NO && tty_playback) { + # Clear playback mode. + + call zclstx (tty_pbinchan, status) + tty_pbinchan = NULL + tty_playback = false + } + + call sfree (sp) +end + + +# ZTT_PBOFF -- Called during error recovery to disable playback mode. + +procedure ztt_pboff (errcode) + +int errcode # error status + +int status +include "zfiott.com" + +begin + if (errcode != OK && tty_playback) { + call zclstx (tty_pbinchan, status) + tty_pbinchan = NULL + tty_playback = false + tty_rawmode = false + tty_passthru = false + } +end + + +# ZTT_LOGDEV -- Record the names of the terminal and stdgraph devices in a +# logfile. The format ("\X=devname\n") MUST agree with that in ztt_getlog. +# Also timestamp the logfile. + +procedure ztt_logdev (chan) + +int chan # output file + +int status +pointer sp, obuf, devname +int envfind(), strlen() + +begin + call smark (sp) + call salloc (obuf, SZ_LINE, TY_CHAR) + call salloc (devname, SZ_FNAME, TY_CHAR) + + # Timestamp the new entry in the logfile. + call strcpy ("\O=", Memc[obuf], SZ_LINE) + call sysid (Memc[obuf+3], SZ_LINE-3) + call strcat ("\n", Memc[obuf], SZ_LINE) + call zputtx (chan, Memc[obuf], strlen(Memc[obuf]), status) + + if (envfind ("terminal", Memc[devname], SZ_FNAME) > 0) { + call strcpy ("\T=", Memc[obuf], SZ_LINE) + call strcat (Memc[devname], Memc[obuf], SZ_LINE) + call strcat ("\n", Memc[obuf], SZ_LINE) + call zputtx (chan, Memc[obuf], strlen(Memc[obuf]), status) + } + if (envfind ("stdgraph", Memc[devname], SZ_FNAME) > 0) { + call strcpy ("\G=", Memc[obuf], SZ_LINE) + call strcat (Memc[devname], Memc[obuf], SZ_LINE) + call strcat ("\n", Memc[obuf], SZ_LINE) + call zputtx (chan, Memc[obuf], strlen(Memc[obuf]), status) + } + + call sfree (sp) +end + + +# ZTT_PUTLOG -- Put a message to the logfile. All characters in the data +# string are rendered into printable form. Long lines are broken and the +# output is followed by a newline. + +procedure ztt_putlog (chan, dstr, nchars) + +int chan # kernel i/o channel +char dstr[ARB] # data string +int nchars # length of data string (0 if EOS delimited) + +char cch +pointer sp, obuf, op +int status, ip, ch, n +int strlen(), ctocc() +define output {Memc[op]=($1);op=op+1} +include "zfiott.com" + +begin + # It is harmless to call us if logging is disabled. + if (!tty_login && !tty_logout) + return + + call smark (sp) + call salloc (obuf, SZ_LINE, TY_CHAR) + + n = nchars + if (n <= 0) + n = strlen (dstr) + + # Output the data string, rendering all characters into printable form. + # Break long lines. The characters \ and ^ must be escaped since they + # are logfile metacharacters. Data spaces are output as \s since + # whitespace in the logfile is ignored. + + op = obuf + do ip = 1, n { + ch = dstr[ip] + if (ch == ' ') { + output ('\\') + output ('s') + } else if (ch == '^' || ch == '\\') { + output ('\\') + output (ch) + } else if (IS_PRINT (ch)) { + output (ch) + } else if (ch == NUL) { + output ('^') + output ('@') + } else { + cch = ch + op = op + ctocc (cch, Memc[op], 5) + } + + if (op - obuf >= RMARGIN && ip+1 < n) { + output ('\\') + output ('\n') + call zputtx (chan, Memc[obuf], op-obuf, status) + for (op=obuf; op < obuf+4; op=op+1) + Memc[op] = ' ' + } + } + + # Terminate and output the line. + if (op > obuf) { + output ('\n') + call zputtx (chan, Memc[obuf], op-obuf, status) + call zflstx (chan, status) + } + + call sfree (sp) +end + + +# ZTT_GETLOG -- Read text from a logfile written by ztt_putlog. All control +# codes and spaces are rendered into escape sequences; newline marks the end +# of each record and an escaped newline followed by leading whitespace on a +# line indicates continuation. Blank lines in the logfile equate to null +# length records and are ignored. + +procedure ztt_getlog (chan, obuf, maxch, nchars) + +int chan # kernel input channel (text file) +char obuf[maxch] # output buffer +int maxch # max chars to return +int nchars # nchars returned or EOF + +bool incom +int lastch, ch, op, o +char cch, cc[4], devname[SZ_DEVNAME] +int ztt_getchar(), cctoc() +include "zfiott.com" + +begin + # Process characters and escape sequence encoded characters from + # the logfile until either maxch character have been output or an + # unescaped newline is seen. Ignore empty lines. Text enclosed + # in \{ ... \} (comment text) is returned without change. + + incom = false + ch = NULL + + for (op=1; op <= 1 && ch != EOF; ) { + while (op <= maxch) { + # Get the next character (not efficient, but doesn't matter + # since this is only called in `stty playback' mode). + + if (ztt_getchar (chan, ch) == EOF) { + break + } else if (IS_WHITE (ch) && !incom) { + next + } else if (ch == '\n' && !incom) { + break + + } else if (ch == '^') { + # Map a control code, e.g., ^[. + if (ztt_getchar (chan, ch) == EOF) + break + ch = mod (ch, 40B) + + } else if (ch == '\\') { + # Map an escape sequence, e.g., \n, \r, \^, \040, etc. + if (ztt_getchar (chan, ch) == EOF) + break + + switch (ch) { + case '\n': + next + case 's': + ch = ' ' + # output ch, below + + case BEGINCOM, ENDCOM: + # Copy a \{ ... \} logfile comment (to be echoed but + # not returned as data). + + obuf[op] = '\\' + op = op + 1 + obuf[op] = ch + op = op + 1 + + incom = (ch == BEGINCOM) + next + + case 'T', 'G', 'O', '#': + # Recall a terminal or stdgraph device name from the + # logfile (device used when logfile was written). + # The format must be "\X=devname\n". \O is the + # timestamp string, which we simply read and discard. + # \# is for logfile comments. + + lastch = ch + o = 1 + repeat { + if (ztt_getchar (chan, ch) == EOF) + break + else if (ch == '\n') + break + else { + devname[o] = ch + o = min (SZ_DEVNAME, o + 1) + } + } + devname[o] = EOS + + if (lastch == 'T') + call strcpy (devname[2], tty_tdevice, SZ_DEVNAME) + else if (lastch == 'G') + call strcpy (devname[2], tty_gdevice, SZ_DEVNAME) + next + + case '^', '\\': + # output ch, below + + default: + cc[1] = '\\' + cc[2] = ch + if (IS_DIGIT (ch)) { + for (o=3; o <= 4; o=o+1) + if (ztt_getchar (chan, ch) == EOF) + break + else + cc[o] = ch + cc[o] = EOS + } else + cc[3] = EOS + o = 1; o = cctoc (cc, o, cch) + ch = cch + # output ch, below + } + } + + obuf[op] = ch + op = op + 1 + } + } + + nchars = op - 1 +end + + +# ZTT_QUERY -- Called in playback mode to echo a line of logfile input text to +# the terminal and wait for the user to tap the CONTINUE key to continue. +# If the response is QUIT playback mode is terminated and input is restored +# to the terminal. If the response is GO verify mode is disabled for the +# remainder of the playback session. It would be easy for us to allow the +# user to edit the command line rather than just accept it, but this could too +# easily cause loss of sync with the input logfile, hence is not allowed. +# Echoing and verify are disabled if raw mode is in effect. + +int procedure ztt_query (logtext, nchars, dtext, maxch, sz_dtext) + +char logtext[ARB] # line of text from logfile +int nchars # nchars in logfile text +char dtext[maxch] # line of text to be returned from zgettt +int maxch # max chars returned +int sz_dtext # actual chars returned + +char text[1] +pointer sp, etext, ep +bool learn, incom, verify, format_control +int status, delay, ip_save, ip, op, ch, n + +int ctoi() +include "zfiott.com" +define done_ 91 +define deposit_ 92 + +begin + call smark (sp) + call salloc (etext, SZ_LINE, TY_CHAR) + + # The logfile line may contain embedded sequences of text which are + # to be echoed to the terminal, but which are not to be returned as + # data to the calling program. This comment or explanatory text is + # enclosed in braces as "\{ ... \}". Control over the verify/delay + # parameters may be specified for the command block by modifying + # the opening sequence, i.e., "\{%V+ ..." sets verify mode for the + # block, "\{%V-" disables verify mode, and "\{%NNNN sets the delay + # to NNNN msec. A leading !, e.g., "%!V+" causes the change to be + # "learned", i.e., the control parameter is permanently changed. + + verify = (tty_verify && !tty_rawmode) + delay = tty_delay + incom = false + ep = etext + op = 1 + + # Process the logfile text into the text to be echoed and the data + # (obuf) text to be returned to the calling program. + + format_control = false + for (ip=1; ip <= nchars; ) { + if (logtext[ip] == '\\') { + if (ip < nchars && logtext[ip+1] == BEGINCOM) { + # Begin comment section. + ip = ip + 2 + incom = true + + # Check for the verify/delay overrides. + while (logtext[ip] == '%') { + ip_save = ip + ip = ip + 1 + + # If !V+ or !delay, learn new value. + learn = (logtext[ip] == '!') + if (learn) + ip = ip + 1 + + if (logtext[ip] == 'V') { + ip = ip + 1 + if (logtext[ip] == '+') { + verify = true + if (learn) + tty_verify = true + ip = ip + 1 + } else if (logtext[ip] == '-') { + verify = false + if (learn) + tty_verify = false + ip = ip + 1 + } else + ip = ip_save + } else if (IS_DIGIT (logtext[ip])) { + if (ctoi (logtext, ip, delay) <= 0) { + delay = tty_delay + ip = ip_save + } else if (learn) + tty_delay = delay + } + + if (ip > ip_save) + format_control = true + else + break + } + + } else if (incom && ip < nchars && logtext[ip+1] == ENDCOM) { + # End comment section. + ip = ip + 2 + incom = false + } else + goto deposit_ + + } else { +deposit_ # Do not include the trailing data-newline in the echo text. + if (incom || (!tty_rawmode && logtext[ip] != '\n')) { + Memc[ep] = logtext[ip] + ep = ep + 1 + } + if (logtext[ip] == '\n' && ip < nchars) { + if (ep > etext) { + n = ep - etext + call zputty (tty_koutchan, Memc[etext], ep-etext, n) + call zflsty (tty_koutchan, status) + } + ep = etext + } + if (!incom) { + op = min (maxch, op) + dtext[op] = logtext[ip] + op = op + 1 + } + ip = ip + 1 + } + } + + # Don't need to add EOS for counted kernel i/o strings. + sz_dtext = op - 1 + + # Output any remaining echo text. + if (ep > etext) { + n = ep - etext + call zputty (tty_koutchan, Memc[etext], n, status) + call zflsty (tty_koutchan, status) + ep = etext + } + + # Do not verify or delay for blank lines with no format control. + if (!format_control && sz_dtext == 1 && dtext[1] == '\n') { + ch = NULL + goto done_ + } + + # If verify is disabled, return after the specified delay. + if (!verify) { + call zwmsec (delay) + ch = NULL + goto done_ + } + + # If verify is enabled, wait for user response. Note that the 1 + # char read leaves the terminal in raw mode. + + repeat { + call zgetty (tty_kinchan, text, 1, status) + if (status > 0) + ch = text[1] + else + ch = EOF + + if (ch == EOF || ch == INTCHAR || ch == QUIT) { + call ztt_playback (NO) + ch = QUIT + break + } else if (ch == GO) { + tty_verify = false + break + } else if (ch == CONTINUE || ch == CONTINUE_ALT) { + break + } else { + # Ignore other characters. + call ztt_ttyput (HELP) + } + } + + # Restore terminal to line mode, if raw mode was not already in + # effect before our query. + + if (!tty_rawmode) + call ztt_ttyput (RAWOFF) + +done_ + if (dtext[sz_dtext] == '\n') + call ztt_ttyput ("\n") + + call sfree (sp) + return (ch) +end + + +# ZTT_GETCHAR -- Get a character from a channel. + +int procedure ztt_getchar (chan, ch) + +int chan # input channel +int ch # receives character + +char text[1] +int status + +begin + call zgettx (chan, text, 1, status) + if (status <= 0) { + ch = EOF + return (EOF) + } else { + ch = text[1] + return (ch) + } +end + + +# ZTT_LOWERCASE -- Map a character string input in upper case to lower case. +# Control sequences may be embedded in the sequence to artifically generate +# upper case characters. +# +# ^ shift up next character +# ^+ shift lock (stay in upper case) +# ^- clear shift lock +# ^^ a single ^ +# +# The case shift control sequences are shown above. These are not recognized +# when the terminal is in raw mode. + +int procedure ztt_lowercase (in, out, nchars) + +char in[ARB] # input string +char out[ARB] # output string +int nchars # input string length + +int ch +int ip, op +include "zfiott.com" + +begin + op = 1 + for (ip=1; ip <= nchars; ip=ip+1) { + ch = in[ip] + + if (ch == CTRLCHAR) { + ch = in[ip+1] + ip = ip + 1 + + switch (ch) { + case CTRLCHAR: + out[op] = ch + op = op + 1 + case SHIFTLOCK: + tty_shiftlock = true + case SHIFTOFF: + tty_shiftlock = false + default: + if (IS_LOWER (ch)) + ch = TO_UPPER (ch) + out[op] = ch + op = op + 1 + } + } else if (tty_shiftlock) { + if (IS_LOWER (ch)) + ch = TO_UPPER (ch) + out[op] = ch + op = op + 1 + } else { + if (IS_UPPER (ch)) + ch = TO_LOWER (ch) + out[op] = ch + op = op + 1 + } + } + + return (op - 1) +end + + +# ZTT_UPPERCASE -- Convert a string to upper case. + +procedure ztt_uppercase (in, out, nchars) + +char in[ARB] # input string +char out[ARB] # output string +int nchars # string length + +int ch, i + +begin + do i = 1, nchars { + ch = in[i] + if (IS_LOWER (ch)) + ch = TO_UPPER (ch) + out[i] = ch + } +end + + +# ZTT_TTYPUT -- Write directly to the user terminal. + +procedure ztt_ttyput (message) + +char message[ARB] # message string + +int status +int stridxs(), strlen() +include "zfiott.com" + +begin + call zputty (tty_koutchan, message, strlen(message), status) + if (stridxs ("\n", message) > 0) + call zflsty (tty_koutchan, status) +end + + +# ZSETTT -- Set TT terminal driver options. Must be called before any i/o is +# done via the TT driver, e.g., by fio$finit. + +procedure zsettt (chan, param, value) + +int chan # kernel i/o channel (not used) +int param # parameter to be set +int value # new value + +bool itob() +bool first_time +data first_time /true/ +include "zfiott.com" + +begin + switch (param) { + case TT_INITIALIZE: + if (!first_time) { + # Close any open log files. + call ztt_playback (NO) + call ztt_logio (NO, NO) + } + + tty_inlogchan = NULL + tty_outlogchan = NULL + tty_pbinchan = NULL + tty_ucasein = false + tty_ucaseout = false + tty_shiftlock = false + tty_rawmode = false + tty_logio = false + tty_login = false + tty_logout = false + tty_playback = false + tty_verify = false + tty_passthru = false + tty_delay = PBDELAY + tty_filter = NULL + tty_filter_key = 0 + + call strcpy (IOFILE, tty_iofile, SZ_FNAME) + call strcpy (INFILE, tty_infile, SZ_FNAME) + call strcpy (OUTFILE, tty_outfile, SZ_FNAME) + call strcpy (PBFILE, tty_pbfile, SZ_FNAME) + + tty_tdevice[1] = EOS + tty_gdevice[1] = EOS + tty_inbuf[1] = EOS + tty_ip = 1 + + first_time = false + + case TT_KINCHAN: + tty_kinchan = value + case TT_KOUTCHAN: + tty_koutchan = value + case TT_LOGINCHAN: + tty_inlogchan = value + case TT_LOGOUTCHAN: + tty_outlogchan = value + case TT_PBINCHAN: + tty_pbinchan = value + case TT_SHIFTLOCK: + tty_shiftlock = itob (value) + case TT_RAWMODE: + tty_rawmode = itob (value) + + case TT_UCASEIN: + tty_ucasein = itob (value) + case TT_UCASEOUT: + tty_ucaseout = itob (value) + + case TT_LOGIO: + tty_logio = true + call ztt_logio (value, value) + case TT_LOGIN: + tty_logio = false + call ztt_logio (value, DONTCARE) + case TT_LOGOUT: + tty_logio = false + call ztt_logio (DONTCARE, value) + case TT_PASSTHRU: + tty_passthru = itob (value) + + case TT_PLAYBACK: + call ztt_playback (value) + case TT_PBVERIFY: + tty_verify = itob (value) + case TT_PBDELAY: + tty_delay = value + + case TT_FILTER: + tty_filter = value + case TT_FILTERKEY: + tty_filter_key = value + + default: + # (ignore) + } +end + + +# ZSTTTT -- Stat TT terminal driver options. Check for the special TT params, +# else pass the request to the hardware driver. + +procedure zstttt (fd, param, lvalue) + +int fd # file number (not used) +int param # parameter to be set +long lvalue # new value + +int btoi() +include "zfiott.com" + +begin + switch (param) { + case TT_KINCHAN: + lvalue = tty_kinchan + case TT_KOUTCHAN: + lvalue = tty_koutchan + case TT_LOGINCHAN: + lvalue = tty_inlogchan + case TT_LOGOUTCHAN: + lvalue = tty_outlogchan + case TT_PBINCHAN: + lvalue = tty_pbinchan + case TT_UCASEIN: + lvalue = btoi (tty_ucasein) + case TT_UCASEOUT: + lvalue = btoi (tty_ucaseout) + case TT_SHIFTLOCK: + lvalue = btoi (tty_shiftlock) + case TT_RAWMODE: + lvalue = btoi (tty_rawmode) + case TT_LOGIO: + lvalue = btoi (tty_logio) + case TT_LOGIN: + lvalue = btoi (tty_login) + case TT_LOGOUT: + lvalue = btoi (tty_logout) + case TT_PASSTHRU: + lvalue = btoi (tty_passthru) + case TT_PLAYBACK: + lvalue = btoi (tty_playback) + case TT_PBVERIFY: + lvalue = btoi (tty_verify) + case TT_PBDELAY: + lvalue = tty_delay + case TT_FILTER: + lvalue = tty_filter + case TT_FILTERKEY: + lvalue = tty_filter_key + default: + call zsttty (fd, param, lvalue) + } +end + + +# ZSESTT -- Set a TT terminal driver string valued option. + +procedure zsestt (fd, param, svalue) + +int fd # file number (not used) +int param # parameter to be set +char svalue[ARB] # new value + +include "zfiott.com" + +begin + switch (param) { + case TT_IOFILE: + call strcpy (svalue, tty_iofile, SZ_FNAME) + case TT_INFILE: + call strcpy (svalue, tty_infile, SZ_FNAME) + case TT_OUTFILE: + call strcpy (svalue, tty_outfile, SZ_FNAME) + case TT_PBFILE: + call strcpy (svalue, tty_pbfile, SZ_FNAME) + case TT_TDEVICE: + call strcpy (svalue, tty_tdevice, SZ_DEVNAME) + case TT_GDEVICE: + call strcpy (svalue, tty_gdevice, SZ_DEVNAME) + default: + # (ignore) + } +end + + +# ZSTSTT -- Stat TT terminal driver string valued option. + +procedure zststt (fd, param, outstr, maxch, nchars) + +int fd # file number (not used) +int param # parameter to be set +char outstr[maxch] # string value +int maxch # max chars out +int nchars # len (outstr) + +int gstrcpy() +include "zfiott.com" + +begin + switch (param) { + case TT_IOFILE: + nchars = gstrcpy (tty_iofile, outstr, maxch) + case TT_INFILE: + nchars = gstrcpy (tty_infile, outstr, maxch) + case TT_OUTFILE: + nchars = gstrcpy (tty_outfile, outstr, maxch) + case TT_PBFILE: + nchars = gstrcpy (tty_pbfile, outstr, maxch) + case TT_TDEVICE: + nchars = gstrcpy (tty_tdevice, outstr, maxch) + case TT_GDEVICE: + nchars = gstrcpy (tty_gdevice, outstr, maxch) + default: + nchars = 0 + } +end + + +# The following functions are straight pass throughs to the hardware +# driver for this device. +# -------------------------- + +# ZOPNTT -- Open a terminal. + +procedure zopntt (osfn, mode, chan) + +char osfn[ARB] # UNIX filename +int mode # file access mode +int chan # UNIX channel of file (output) + +begin + call zopnty (osfn, mode, chan) +end + + +# ZCLSTT -- Close a terminal. + +procedure zclstt (fd, status) + +int fd # channel +int status # return status + +begin + call zclsty (fd, status) +end + + +# ZFLSTT -- Flush any buffered terminal output. + +procedure zflstt (fd, status) + +int fd # channel +int status # return status + +begin + call zflsty (fd, status) +end + + +# ZSEKTT -- Seek on a text file to the character offset given by a prior +# call to ZNOTTT. This offset should always refer to the beginning of a line. +# (not used for terminals). + +procedure zsektt (fd, offset, status) + +int fd # channel +long offset # new offset +int status # return status + +begin + call zsekty (fd, offset, status) +end + + +# ZNOTTT -- Return the seek offset of the beginning of the current line +# of text (not used for terminals). + +procedure znottt (fd, offset) + +int fd # channel +long offset # file offset + +begin + call znotty (fd, offset) +end |