From 97d5c458cfa039d857301e1ca7d5af3beb37131d Mon Sep 17 00:00:00 2001
From: Jacob McDonnell <jacob@jacobmcdonnell.com>
Date: Sun, 26 Apr 2026 16:38:00 -0400
Subject: build: Better Build System

---
 static/unix-v10/man1/qed.1 | 1617 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1617 insertions(+)
 create mode 100644 static/unix-v10/man1/qed.1

(limited to 'static/unix-v10/man1/qed.1')

diff --git a/static/unix-v10/man1/qed.1 b/static/unix-v10/man1/qed.1
new file mode 100644
index 00000000..21e7b38d
--- /dev/null
+++ b/static/unix-v10/man1/qed.1
@@ -0,0 +1,1617 @@
+.TH "QED" 1 
+.	\" /*% nroff -man %
+.if t .ds q \(aa
+.if n .ds q '
+.SH NAME
+qed \- multi-file text editor
+.SH SYNOPSIS
+.B qed
+[
+.B \-
+] [
+.B \-i
+] [
+.B \-q
+] [
+.B \-e
+] [
+.B \-x
+startupfile
+] [ filename1 filename2 ... ]
+.SH DESCRIPTION
+\fIQed\fP
+is a multiple-file programmable text editor based on
+.IR ed .
+.PP
+.I Qed
+operates on a copy of any file it is editing; changes made
+in the copy have no effect on the file until a \fIw\fR
+or \fIW\fR (write)
+command is given.
+The copy of the text being edited resides
+in a scratch area called a
+.I buffer.
+There are 56 buffers, labeled by alphabetics `a' to `z' and `A' to `Z',
+and the characters `{', `|', `}' and `~'
+(the four ASCII characters following `z').
+These 56 characters are called, for notational efficiency,
+.I bnames.
+The buffers can contain any ASCII character except NUL.
+.PP
+If
+.I file
+arguments are given,
+.I qed
+simulates an
+.I r
+command (see below) on each of the named files; that is to say,
+the files are read into
+.I qed's
+buffers so that they can be edited.
+The first is read into buffer `a', the second into buffer `b',
+through `z',
+then from `A' to `Z',
+up to a maximum of 52 files.
+The optional
+.B \-
+puts
+.I qed
+in non-\c
+.I verbose
+mode (described with the
+.I o
+command).
+The
+\fB\-q\fR, \fB\-e\fR
+and
+.B \-i
+are equivalent to performing an initial
+`oqs', `oes' or `ois' command (see the
+.I o
+command below).
+.PP
+When \fIqed\fP starts up,
+the file named by the environment variable
+.B QEDFILE
+is read into
+buffer `~' and executed
+(i.e. read as command input), before
+reading in files and accepting commands from the terminal.
+The argument
+.I filename\c
+s are set in the buffers before the startup file is executed,
+so the startup file can treat the \fIfilenames\fR as arguments.
+The default startup file may be overridden with the \fB\-x\fR option.
+.PP
+Input to
+.I qed
+can be redirected, at any time,
+to come from storage such as a buffer
+by use of a
+.I special
+.I character
+such as ``\eb''.
+All the
+.I qed special character
+sequences are discussed in detail below;
+they all begin with a
+backslash `\\'.
+.PP
+.I Qed
+has a 
+.I truth flag
+which is set according to the success of certain commands
+and which can be tested for conditional execution, and a
+.I count
+which is set to such values as the number of successful substitutions
+performed in an
+.I s
+command.
+Each buffer has associated with it a
+(possibly null) filename and a
+.I changed
+flag, which is
+set if the contents of the buffer are known to differ
+from the contents of the named file in that buffer.
+.PP
+Commands to
+.I qed
+have a simple and regular structure: zero or
+more
+.I addresses
+followed by a single character
+\fIcommand\fP,
+possibly
+followed by parameters to the command.
+These addresses specify one or more lines in the buffer.
+Every command which requires addresses has default addresses,
+so that the addresses can often be omitted.
+.PP
+In general, any number of commands can appear on a line.
+Some commands require that the character following
+the command be a separator, such as blank, tab or newline.
+Usually, a
+.I display
+.IR character ,
+.IR p ,
+.IR P ,
+.IR l ,
+or
+.I L
+may precede the separator,
+causing the resulting line to be displayed in the specified format
+after the command.
+Certain commands allow the input of text for placement in the buffer.
+This text can be supplied in two forms:
+either
+on the same line, after the command,
+or on lines following the command,
+terminated by a line containing only a period `\fB.\fP'.
+If the text is on the command line,
+it is separated from the command by a space or a tab.
+If the tab is used, it is considered part of the text.
+.PP
+.I Qed
+supports a limited form of
+\fIregular\fP \fIexpression\fP
+notation.
+A regular expression specifies
+a set of strings of characters.
+A member of this set of strings is said to be
+.I matched
+by the regular expression.
+Regular expressions in
+.I qed
+are delimited by enclosing them in a pair of identical characters,
+frequently slashes `/'.
+In the following specification for regular expressions the word `character'
+means any character but newline.
+Note that special character interpretation always occurs
+.I before
+executing a command.
+Thus, the backslashes mentioned below are those present
+after special characters have been interpreted.
+.IP 1.
+Any character except a metacharacter matches itself.
+Metacharacters are the regular expression delimiter plus
+< [ \fB.\fP and \e | > ^ * \+ $
+when another rule gives them a meaning.
+.IP 2.
+A \fB.\fP matches any character.
+.IP 3.
+A backslash \\ followed by
+any metacharacter in the list given in rule 1
+is a regular expression and matches that character.
+A backslash followed by one of
+! _ { } (  )
+or a non-zero digit
+has a special meaning discussed below;
+otherwise, backslashes have literal meaning in regular expressions.
+.IP 4.
+The metacharacter \e\|! matches any control character
+except tab or newline.
+.IP 5.
+A non-empty string
+.I s
+enclosed in square brackets
+[\fIs\fP] (or [^\fIs\fP]) matches any character in (or not in) \fIs\fP.
+In
+.IR s ,
+\\ has no special meaning, and ] may only appear as the first character.
+A substring
+.IR a \- b ,
+with
+.I a
+and
+.I b
+in ascending ASCII order, stands for the inclusive range of ASCII characters.
+.IP 6.
+A regular expression,
+of the form <\fIx1\fP> or <\fIx1\fR|\|\fIx2\fR|\|...|\|\fIxn\fR>,
+where the \fIx\fR's are regular expressions of form 1-12, matches what
+the leftmost successful \fIx\fR
+matches.
+.IP 7.
+A backslash followed by a non-zero digit
+.I n
+matches a copy of the string that the bracketed regular expression
+(see rule 11)
+beginning with the \fIn\fPth \e\|( matched.
+.IP 8.
+A regular expression of form 1-7 followed by * (\+)
+matches a sequence of zero (one) or more matches of the regular expression.
+.IP 9.
+The metacharacter \\\|_ matches a non-empty
+maximal-length sequence of blanks and tabs.
+.IP 10.
+The metacharacter \\\|{ (\\\|}) matches the empty string at the beginning
+(end) of an identifier.  An identifier is defined to be
+an underscore _ or alphabetic followed by zero or more
+underscores, alphabetics or digits.
+.IP 11.
+A regular expression,
+.IR x ,
+of form 1-12, bracketed \e\|(\|\fIx\fP\|\e\|) matches what
+.I x
+matches.
+The nesting of these brackets in each regular expression of an
+alternation (rule 6) must be identical.
+An alternation with these brackets may not be iterated (rule 8).
+.IP 12.
+A regular expression of form 1-12,
+.IR x ,
+followed by a regular expression of form 1-11,
+.IR y ,
+matches a match for
+.I x
+followed by a match for
+.IR y ,
+with the
+.I x
+match being as long as possible while still permitting a
+.I y
+match.
+.IP 13.
+A regular expression of form 1-12 preceded by ^ (followed by $) is constrained
+to matches that begin at the left (end at the right) end of a line.
+.IP 14.
+A regular expression of form 1-13 picks out the longest among the leftmost matches
+in a line.
+.IP 15.
+An empty regular expression stands for a copy of the last regular expression encountered.
+.PP
+.i0
+Regular expressions are used in addresses and the
+.I g
+and
+.I v
+commands
+to specify
+lines, in the
+.I s
+command
+to specify a portion of a line which is to be replaced,
+in the
+.I G
+and
+.I V
+commands to refer to buffers in which to perform commands,
+and in general whenever text
+is being specified.
+.PP
+To understand addressing in
+.I qed
+it is necessary to know that at any time there is a
+\fIcurrent buffer\fR
+and a
+\fIcurrent line.\fR
+When
+.I qed
+is invoked,
+the current buffer is
+buffer `a',
+but may be changed at any time by a
+.I b
+(change buffer) command.
+All addresses refer to lines in the current buffer,
+except for a special case described under the
+.I m
+(move) command.
+.PP
+Generally speaking, the current line is
+the last line affected by a command; however,
+the exact effect on the current line
+is discussed under the description of
+the command.
+Addresses are constructed as follows.
+.IP 1.
+The character `\fB.\fR' addresses the current line.
+.IP 2.
+The character `$' addresses the last line of the buffer.
+.IP 3.
+A decimal number
+.I n
+addresses the
+\fIn\fR-th
+line of the buffer.
+.IP 4.
+`\*q\fIx\fR' addresses the line marked with the
+mark name character \fIx\fR,
+which must be a bname.
+Lines are marked with the
+.I k
+command described below.
+It is an error for the marked line to be outside of the current buffer.
+.IP 5.
+A regular expression enclosed in slashes `/' addresses
+the first matching line
+found by searching forwards from the line after the current line.
+If necessary, the search wraps around to the beginning of the
+buffer.
+If the trailing `/' would be followed by a newline,
+it may be omitted.
+.IP 6.
+A regular expression enclosed in queries `?' addresses
+the first matching line
+found by searching backwards from the line before
+the current line.
+If necessary
+the search wraps around to the end of the buffer.
+If the trailing `?' would be followed by a newline,
+it may be omitted.
+.IP 7.
+An address followed by a plus sign `+'
+or a minus sign `\-' followed by a decimal number specifies that address plus
+(resp. minus) the indicated number of lines.
+The plus sign may be omitted.
+.IP 8.
+An address followed by `+' or `\-' followed by a
+regular expression enclosed in slashes specifies the first
+matching line following (resp. preceding) that address.
+The search wraps around if necessary.
+The `+' may be omitted.
+Enclosing the regular expression in `?' reverses the search direction.
+.IP 9.
+If an address begins with `+' or `\-'
+the addition or subtraction is taken with respect to the current line;
+e.g. `\-5' is understood to mean `\fB.\fR\-5'.
+.IP 10.
+If an address ends with a `+' (or `\-') 1 is added (resp. subtracted).
+As a consequence of this rule and rule 9,
+the address `\-' refers to the line before the current line.
+Moreover, trailing `+' and `\-' characters have cumulative effect, so `\-\-'
+refers to the current line less 2.
+.IP 11.
+To maintain compatibility with earlier versions of the editor,
+the character `^' in addresses is entirely
+equivalent to `\-'.
+.PP
+.i0
+Commands may require zero, one, or two addresses.
+Commands which require no addresses regard the presence
+of an address as an error.
+Commands which accept one or two addresses
+assume default addresses when none is given.
+If more addresses are given than the command requires,
+the last one or two (depending on what is accepted) are used.
+The last addressed line must not precede the second-last addressed line.
+.PP
+Typically, addresses are separated from each other by a comma `,'.
+They may instead be separated by a semicolon `;'
+in which case the current line `\fB.\fR' is set to the first address
+before the second address is interpreted.
+The second of two separated addresses may not be a line
+earlier in the buffer than the first.
+If the address on the left (right) side of a comma or semicolon
+is absent, it defaults to the first (resp. last) line.
+.PP
+Filename operands of commands may be made up of printing characters only.
+However, when the filename appears as the argument to the invocation of
+\fIqed\fP,
+non-printing characters may be included.
+When a filename is specified for a command,
+it is terminated at the first blank, tab or newline.
+.PP
+In the following list of
+.I qed
+commands, the default addresses
+are shown in parentheses.
+The parentheses are not part of
+the address, but are used to show that the given addresses are
+the default.
+.TP 5
+( \fB. \fR)\|a <text>
+The append command accepts input text
+and appends it after the addressed line.
+`\fB.\fR' is left
+on the last line input, if there
+were any, otherwise at the addressed line.
+Address `0' is legal for this command; text is placed
+at the beginning of the buffer.
+.TP 5
+b<bname>
+The change buffer command sets the current buffer
+to be that named.
+`\fB.\fR', `$' and the remembered
+.I filename
+are set to those of the new buffer;
+upon return to a previously used buffer,
+`\fB.\fR' will be set to its value when the buffer was last used.
+.TP 5
+( \fB. \fR)\|b[+\-\^\fB.\fP\^][pagesize][display character]
+The browse command provides page-oriented printing.
+The optional `+', `\-', or
+.RB ` . '
+specifies whether the next,
+previous,
+or surrounding page
+is to be printed; if absent, `+' is assumed.
+.IB b .
+also prints several carets `^^^^^'
+immediately below the current line.
+If a pagesize is given, it is used for the current browse
+command and remembered as the default.
+The pagesize is initially 22 lines.
+If a display character is given,
+the lines are printed in the specified format,
+and the format is remembered as the default.
+Initially, `p' is the default.
+For
+.I b+
+and
+.IR b\- ,
+`\fB.\fP' is left at the last line displayed;
+for
+\fIb\fP\fB.\fP,
+it is unchanged.
+NOTE: The browse and change buffer commands are the same character!
+The two commands can be syntactically distinguished
+in all cases except for `b<display\ char>';
+this ambiguity may be resolved by typing the (implicit) `+'
+after the `b'.
+.TP 5
+( \fB. \fR, \fB. \fR)\|c <text>
+The change
+command deletes the addressed lines, then accepts input
+text which replaces these lines.
+`\fB.\fR' is left at the last line input; if there were none,
+it is left at the line preceding the deleted lines.
+If an interrupt signal (usually ASCII DEL) is received during a
+change command, the old lines are not deleted.
+.TP 5
+( \fB. \fR, \fB. \fR)\|d
+The delete command deletes the addressed lines from the buffer.
+The line after the deleted section becomes the current line;
+if the deleted lines were originally at the end,
+the new last line becomes the current line.
+The character after the `d' can only be one of
+a blank, newline, tab, or display character.
+Line 0 is a valid address for deletion;
+deleting line 0 has no affect on any lines in the buffer.
+.TP 5
+e filename
+The edit
+command causes the entire contents of the current buffer to be deleted,
+and then the named file to be read in.
+`\fB.\fR' is set to the last line of the buffer.
+The number of characters read is typed
+if
+.I qed
+is in
+.I verbose
+mode.
+The \fIfilename\fP is remembered for possible use as a default file name
+in a subsequent
+\fIf\fP, \fIr\fR, \fIw\fR, or \fIW\fR command.
+.TP 5
+E filename
+The
+.I E
+command is like
+.IR e ,
+except that
+.I qed
+does not check to see
+if the buffer has been modified
+since the last
+.I w
+command.
+.TP 5
+f filename
+The filename command prints information about the current buffer,
+in the format used by the \fIn\fR command.
+If \fIfilename\fP is given,
+the currently remembered file name is changed to \fIfilename\fP.
+If
+.I qed
+is not in verbose mode,
+the information is only printed if the
+.I filename
+is not specified.
+If it is not desired to set the
+.I filename,
+the character immediately after the f must be a newline.
+Otherwise, the first token
+(which may be the null string)
+on the line, after a mandatory non-empty sequence of blanks and tabs,
+is taken to be the
+.I filename.
+These rules apply to all
+.I filename\c
+-using commands,
+.I e,
+.I f,
+.I r,
+.I R,
+.I S,
+.I w
+and
+.I W,
+although some regard specification of an explicitly null \fIfilename\fP as an
+error.
+.TP 5
+( 1 , $ )\|g/regular expression/command list
+In the global
+command, the first step is to mark every line in the range which matches
+the regular expression.
+Then for every such line, the
+command list is executed with `\fB.\fR' initially set to that line.
+Any embedded newlines in the command list
+must be escaped with a backslash.
+The
+\fIa\fP,
+\fIi\fP,
+and
+.I c
+commands and associated input are permitted;
+the `\fB.\fR' terminating input mode may be omitted if it would be on the
+last line of the command list.
+The commands
+.I g
+and
+.I v
+are not permitted in the command list.
+If the command list is empty, `\fB.\fPp' is assumed.
+The regular expression may be delimited by any character other than newline.
+.TP 5
+G/regular expression/command list
+In the globuf
+command, the first step is to mark every active buffer
+whose output from an
+.I f
+command
+(with the
+.I filename
+printed literally)
+would match the regular expression.
+(An active buffer is one which has either some text or
+a remembered file name.)\ 
+Then for every such buffer, the
+command list is executed with the current buffer set to that buffer.
+In other respects it is like the global command,
+except that only the commands
+.I G
+and
+.I V
+are not permitted in the command list.
+If the command list is empty, `f' is assumed.
+.TP 5
+h<option> command list
+The until command provides a simple looping mechanism.
+The command list is a newline-terminated command sequence which forms
+the body of the loop; embedded newlines must be escaped with a backslash.
+The option specifies the exit condition for the loop,
+and is specified by the character(s) immediately following the `h':
+.RS
+.IP h[\fIN\fP]t 6
+The loop is executed until the truth flag is true.
+.PD 0
+.IP h[\fIN\fP]f 6
+The loop is executed until the truth flag is false.
+.IP h[\fIN\fP] 6
+The loop is executed indefinitely.
+.RE
+.PD
+.IP
+The loop condition is tested
+.I after
+execution, so the `ht' and `hf' forms execute at least once.
+.I N
+denotes an optional non-negative number which indicates the
+maximum number of times to execute the loop.
+.TP 5
+( \fB. \fR)\|i <text>
+The insert command accepts input text
+and inserts it before the addressed line.
+`\fB.\fR' is left at the last line input; if there were none,
+at the line before the addressed line.
+This command differs from the
+.I a
+command only in the placement of the
+text.
+.TP 5
+( \fB.\fR\-1 , \fB. \fR)\|j
+.PD 0
+.TP 5
+( \fB.\fR\-1 , \fB. \fR)\|j\|/replacement/
+.PD
+The join command collapses all addressed lines into a single line by
+deleting intermediate newlines.
+The
+.I replacement
+(if any) is placed between joined lines.
+Newlines, backslashes `\\', and slashes `/' within
+.I replacement
+must be preceded by a backslash.
+Only slashes may delimit \fIreplacement\fP.
+`\fB.\fP' is left at the resulting line.
+NOTE: The join command in
+.I qed
+has a different default addressing from that in
+.I ed.
+.TP 5
+( \fB. \fR)\|k<bname>
+The mark command marks the addressed line with
+the given bname.
+(The bname used in the mark has no relation to any buffer;
+it is just a label.)\ 
+The address form `\*q<bname>'
+then addresses this line.
+`\fB.\fR' is not changed.
+The marks are global to
+.I qed\c
+; marking a line `x' erases any previous mark `x' in any buffer.
+.TP 5
+( \fB. \fR, \fB. \fR)\|l
+The list command
+prints the addressed lines in an unambiguous way:
+a tab is printed as `\et', a backspace as `\\b',
+a backslash as `\e\e',
+a non-printing character is
+printed as a backslash followed by three octal digits,
+and a long line is folded,
+with the second and subsequent sub-lines indented one tab stop.
+If the last character in the line is a blank,
+it is followed by `\\n'.
+.TP 5
+( \fB. \fR, \fB. \fR)\|L
+The \fIL\fP command
+is similar to the \fIl\fP command,
+but each line displayed is preceded by its line number,
+any marks it has (which appear as `\*q\fIx\fR'),
+and a tab.
+.TP 5
+( \fB. \fR, \fB. \fR)\|m\fIa\fR
+The move command repositions the addressed lines after the line
+addressed by
+\fIa\fP.
+The last of the moved lines becomes the current line.
+The address \fIa\fP can also be of the form
+<bname>address,
+in which case the text is moved after the address in the named
+buffer.
+The buffer to which the text was moved becomes the current buffer.
+The original buffer (if different) has `\fB.\fR' left at the line before the moved lines.
+.TP 5
+n
+The names command displays the bname,
+dollar
+and \fIfilename\fR (in `l' format) of the current buffer and all active buffers.
+If the buffer's changed flag is set, an apostrophe `\*q' is printed
+after the bname.
+The current buffer is indicated by a period `\fB.\fP' before the
+dollar value.
+If present, the
+.I filename
+is preceded by a tab.
+.TP 5
+N
+The \fIN\fP command is similar to the \fIn\fP command,
+but the display is only given for those buffers
+which have a \fIfilename\fP and for which the changed flag is set.
+.TP 5
+o\fIps\fP
+The option command allows various options to be set.
+The first argument, \fIp\fP,
+specifies which option is being set.
+The rest of the command, \fIs\fP,
+specifies the setting.
+Most options can be either enabled or disabled;
+\fIs\fP is `s' to set the option,
+or `r' to reset it.
+The following table describes the available options.
+The default setting is shown after the option's letter.
+.RS
+.IP b22p 5
+Set the length and format of the page printed by the browse command.
+Either the length or the format may be omitted.
+.PD 0
+.IP "B<null string>" 5
+Set the default command sequence to be
+performed when a newline command is typed at the terminal.
+The command sequence is set by following the `B' with a newline-terminated
+string.
+If the string is null, the newline command resumes its default behaviour.
+.IP cr 5
+Set the changed flag of the current buffer.
+.IP dr 5
+Dualcase search mode
+affects rule one of regular expression construction
+so that a letter is matched without regard to its case.
+.IP er 5
+Error exit mode causes
+.I qed
+to exit if an error occurs (see the DIAGNOSTICS section).
+This option is mainly intended for use of qed in shell files.
+.IP ir 5
+Interrupt catching mode causes
+.I qed
+to exit when interrupted. (This includes removing the temporary file).
+.IP pr 5
+Prompting mode causes `*' to be typed
+immediately before a command (as opposed to text)
+is read from the terminal.
+.IP qr 5
+Quit catching mode causes
+.I qed
+to dump core, leaving the temporary file intact,
+when a QUIT signal is received.
+.IP Tr 5
+Tracing mode causes
+all commands not typed directly by the user to be echoed on the terminal.
+When a special character (other than `\eB or `\eN')
+is encountered, a `[' is typed,
+followed by a code specifying the character \(em
+`za' for register `a', `g' for global command list,
+`l' for `\el', `B' for browse pseudo-register, etc.
+Then, an `=' is typed, followed by the interpretation
+of the special character, followed by a `]'.
+.IP us 5
+Uppercase conversion mode enables case transformation in
+substitute commands.
+If the `u' flag is set, the character caret (`^') 
+becomes non-literal in the replacement text of a substitution.
+It behaves just like `&', but with case switching of alphabetics
+in the replaced text.
+If the flag is `u', all alphabetics are mapped to upper case;
+if `l', lower case; and if `s', the case is switched.
+.IP vs 5
+Verbose mode causes character counts to be typed
+after
+\fIe\fP,
+\fIr\fP,
+\fIw\fP,
+\fIR\fP,
+\fIS\fP,
+and
+.I W
+commands.
+It also causes `!' to be typed upon completion of the \fI!\fR,
+\fI<\fR, \fI|\fR  and \fI>\fR commands.
+.IP ?\fIc\fP 5
+\fIc\fP must be one of
+`c', `d', `i', `p', `T' or `v'.
+The value of the corresponding flag is stored in the truth.
+.PD
+.RE
+.TP 5
+( \fB. \fR, \fB. \fR)\|p
+The print command prints the addressed lines.
+`\fB.\fR' is left at the last line printed.
+.TP 5
+( \fB. \fR, \fB. \fR)\|P
+The PRINT command is similar to the print command,
+but each line displayed is preceded by its line number,
+any marks it has (which appear as `\*q\fIx\fR'),
+and a tab.
+.TP 5
+q
+The quit command causes
+.I qed
+to exit.
+No automatic write
+of a file is done.
+If the changed flag is set
+in any buffer,
+.I qed
+prints `?q'
+and refuses to quit.
+A second
+.I q
+or a
+.I Q
+will get out regardless,
+as will an end-of-file
+on the standard input.
+.TP 5
+Q
+Like
+.IR q ,
+but changed flags
+are not checked.
+.TP 5
+( $ )\|r filename
+The read command
+reads in the given file after the addressed line.
+If no \fIfilename\fP is given,
+the remembered \fIfilename\fP is used
+(see
+.I e
+and
+.I f
+commands).
+The \fIfilename\fP is remembered if there was not already a
+remembered \fIfilename\fP in the current buffer.
+Address `0' is legal for
+.I r
+and causes the
+file to be read at the beginning of the buffer.
+If
+.I qed
+is in
+.I verbose
+mode and the read is successful, the number of characters
+read is typed,
+except while
+.I qed
+is starting up,
+in which case an
+.I f
+command is performed.
+`\fB.\fR' is left at the last line read in from the file.
+.TP 5
+R filename
+The restore command restores an environment saved by a save (\fIS\fR) command.
+The changed flag in each buffer is restored from the files; all other flags
+are unaffected.
+The input stack is reset to the top (teletype input) level,
+and the current buffer becomes `a'.
+`\fB.\fP' is left at the saved value of `\fB.\fP' in buffer `a'\fB.\fP
+If the \fIfilename\fP is not specified, `q' is used.
+.TP 5
+( \fB. \fR, \fB. \fR)\|s\fIn\fR/regular expression/replacement/
+.PD 0
+.TP 5
+( \fB. \fR, \fB. \fR)\|s\fIn\fR/regular expression/replacement/g
+.PD
+The substitute command searches each addressed
+line for occurrences of the specified regular expression.
+The decimal number \fIn\fP defaults to 1 if missing.
+On each line in which
+.I n
+matches are found,
+the \fIn\fPth matched string is replaced with
+\fIreplacement\fP.
+If the global replacement indicator `g' follows the command,
+all subsequent matches on the line are also replaced.
+Within a line, a search starts from the character following the last match,
+unless the last match was an empty string,
+in which case the search starts at
+the second character following the empty string
+(to ensure a match is not repeated).
+It is an error for the substitution to fail on all addressed lines
+unless it is in a global command.
+`\fB.\fR' is left at the last line substituted.
+.PP
+.RS
+Any character other than newline or a numeral
+may be used instead of `/' to delimit the regular expression
+and \fIreplacement\fP.
+If the trailing delimiter is missing
+(i.e., an unescaped newline
+in the
+.IR replacement ),
+its presence is assumed,
+and the last line affected is printed,
+as if the
+substitute
+was followed by a
+.I p
+command.
+If delimiter following the expression
+is omitted as well,
+an empty
+.I replacement
+is assumed.
+.PP
+An ampersand `&' appearing in \fIreplacement\fP
+is replaced by the string matching the regular expression.
+As a more general feature,
+the characters
+`\\\fIn\fR',
+where
+.I n
+is a digit,
+are replaced by the text matched by the
+\fIn\fR-th
+regular subexpression
+enclosed between `\e\|(' and `\e\|)'.
+When nested parenthesized subexpressions are present,
+.I n
+is determined by counting occurrences of `\e\|(' starting from the left.
+.PP
+A caret `^' appearing in \fIreplacement\fP
+behaves much like an ampersand,
+but provides a mechanism for case switching of alphabetics,
+as discussed under the \fIo\fR command.
+To include an ampersand `&', caret `^', backslash `\\', newline,
+or the delimiter literally in
+\fIreplacement\fP,
+the character must be preceded by a backslash.
+Lines may be split by substituting newline characters into them.
+.RE
+.TP 5
+S filename
+The save command saves the full buffer and register information in two
+files called `filename:aq' and `filename:bq'.
+If the filename is absent, `q' is used.
+If the filename has more than 12 characters after the last slash `/',
+it is truncated to 12 characters to avoid overwriting the file.
+.TP 5
+( \fB.\fR , \fB.\fR )\|t\fIa\fR
+The copy command acts just like the move
+.I m
+command except that a copy of the addressed lines is placed after address
+\fIa\fP.
+`\fB.\fR' is left on the last line of the copy.
+The buffer to which the text was copied becomes the current buffer.
+.TP 5
+u
+The undo command restores the last line changed by a
+\fIs\fP,
+\fIu\fP,
+or
+.I x
+command.
+Any new lines created by splitting the original are left.
+It is an error if the line is not in the current buffer.
+`\fB.\fP' is left at the restored line.
+.TP 5
+( 1 , $ )\|v/regular expression/command list
+This command is the same as the global command
+except that the command list is executed
+with `\fB.\fR' initially set to every line
+.I except
+those
+matching the regular expression.
+.TP 5
+V/regular expression/command list
+This command is the same as the globuf command
+except that the command list is executed
+with the current buffer initially set to every active buffer
+.I except
+those
+matching the regular expression.
+.TP 5
+( 1 , $ )\|w filename
+The write command writes the addressed lines onto
+the given file.
+If the file does not exist,
+it is created.
+The filename is remembered if there was not already a
+remembered file name in the current buffer.
+If no file name is given,
+the remembered file name is used.
+`\fB.\fR' is unchanged.
+If
+.I qed
+is in
+.I verbose
+mode and
+the command is successful, the number of characters written is
+typed.
+.TP 5
+( 1 , $ )\|W
+The \fIW\fP command is the same as the \fIw\fP command except that
+the addressed lines are appended to the file.
+.PP
+.TP 5
+( \fB. \fR, \fB. \fR)\|x
+.RS
+The xform command allows one line at a time to be modified according to
+graphical requests.
+The line to be modified is typed out,
+and then the modify request is read from the terminal
+(even if the xform command is in a global command or other
+nested input source).
+Generally each character in the request specifies how to
+modify the character immediately above it, in the original line,
+as described in the following table.
+.IP # 5
+Delete the above character.
+.PD 0
+.IP % 5
+Replace the above character with a space.
+.IP ^ 5
+Insert the rest of the request line before the above character.
+If the rest of the request line is empty, insert a newline character.
+.IP $ 5
+Delete the characters in the above line from this position on;
+replace them with the rest of the request line.
+.IP "space or tab:" 5
+Leave above character(s) unchanged.
+.IP "any other:" 5
+This character replaces the one above it.
+.PD
+.PP
+If the request line is longer than the line to be modified,
+the overhang is added to the end of the line
+without interpretation,
+that is, without treating `#', `%', `^' or `$' specially.
+Any characters after a `^' or `$' request are not interpreted either.
+.PP
+Xform will not process control characters other
+than tab and newline,
+except in contexts where it need not know their width
+(that is, after a `^' or `$' request, or in the part of
+either the request or the line that overhangs the other).
+Remember that the ERASE character (processed by the system)
+erases the last character typed,
+not the last column.
+.PP
+Some characters take more than one column of the terminal
+to enter or display.
+For example, entering the ERASE or KILL characters literally
+takes two columns because they must be escaped.
+To delete a multi-column character,
+one must type `#' under all its columns.
+To replace a multicolumn character,
+the replacement must be typed under the first column of the character.
+Similarly, if a replacement character is multi-columned,
+it replaces the character in its first column.
+.PP
+The tab character prints as a sequence of spaces, and may be
+modified as if it were that sequence.
+As long as the last space is unmodified, it and the
+remaining contiguous spaces will represent a tab.
+.PP
+The modification process is repeated until the request is empty.
+Only a newline may immediately follow the `x'.
+.RE
+.TP 5
+y<condition><type>
+The jump command controls execution nested input sources.
+The condition is compared to the truth flag to see if the jump
+should be performed;
+if a `t', the jump is performed if the truth flag is true,
+if an `f', the jump is performed if the truth flag is false,
+if absent the jump is always performed.
+Several types of jumps exist:
+.RS
+.IP y[tf]o
+Jump out of the current input source.
+If the current input source is the command line
+for a \fIg\fR, \fIG\fP, \fIv\fR, \fIV\fR or \fIh\fR command, the command is terminated.
+.PD 0
+.IP y[tf]\fIN\fR
+Control is transferred to absolute line \fIN\fR (an integer)
+in the executing buffer.
+The current input source must be a buffer.
+.IP y[tf]\(aa<label>
+Control is transferred to the first line found,
+searching forward in the buffer,
+that begins with a comment "<label>.
+The match of the labels must be exact;
+regular expressions are not used to define the control label.
+(A tab, blank or newline after the double quote specifies a null label:
+a line beginning `"\ \ LAB' cannot be transferred to by this form of jump.)\ 
+If no such label is found,
+control resumes at the character after the label in the jump command.
+The current input source must be a buffer.
+.IP y[tf]\(ga<label>
+Similar to `y\(aa<label>',
+but the search is in the opposite (reverse) direction.
+.IP y[tf]
+If no
+recognized type is given,
+input is skipped up to the next newline.
+.PD
+.RE
+.IP
+It is an error if reading the label or line number for a jump command
+causes the current input source (i.e. buffer) to be `popped.'\ 
+This can happen if the label is the last word in the buffer,
+but can be circumvented by putting an extra blank or newline after
+the jump command.
+.TP 5
+( \fB.\fR , \fB.\fR )\|z\fIXc\fR
+\fIQed\fP has 56 registers labeled by bnames.
+Three of these,
+registers `T', `C', and `U',
+are reserved:
+`T' is the truth flag, `C' is the count,
+`U' contains the
+.SM UNIX
+command from the most recent
+bang, crunch, zap, or pipe command.
+The contents of register \fIX\fP,
+where \fIX\fR is a bname,
+can be inserted into the input
+stream with the special character ``\ez\fIX\fP''.
+The command ``z\fIX\fR''
+specifies register \fIX\fR
+as the argument to
+the operation character (signified above by \fIc\fR) that follows it.
+In the description below,
+\fIN\fR stands for a possibly signed decimal integer
+and \fIS\fR stands for a newline-terminated string.
+Newlines may be embedded in registers by escaping
+them with a backslash.
+Although some of the register commands refer to addressed lines,
+`\fB.\fP' is unaffected by a
+.I z
+command.
+The operations are as follows:
+.RS
+.IP p
+Print the contents of the register in `p' format.
+.PD 0
+.IP l
+Print the contents of the register in `l' format.
+.IP \fB.\fP
+Set the register to the contents of the addressed line.
+.IP /reg-exp/
+Set the register to the portion of
+current line that matches the regular expression in slashes.
+If no such pattern is found,
+the register is cleared.
+The truth flag is set according to whether a
+match was found.
+.IP \fB:\fR\fIS\fR
+Set register to the string following the colon.
+.IP \&\(aa\fIY\fR
+Make a direct copy of register \fIY\fR in register \fIX\fR,
+without interpreting special characters.
+\fIY\fR is any register bname.
+.IP +\fIN\fR
+Increment by \fIN\fR the ASCII value of each character in the register.
+Similarly, a `\-' decrements each character.
+.IP =\fIS\fR
+(Or `<' or `>' or `!=' or `!<' or `!>'.)\ 
+Set truth flag to the result of the lexical comparison
+of the register and the string \fIS\fR.
+.IP n
+Set the count to the length of the register.
+.IP )\|\fIN\fR
+(Or '('.)\ 
+`Take'
+the first \fIN\fR characters of the register, i.e. truncate at the \fIN\fR+1'th
+character.
+`(' (`drop') is the complementary operator;
+it deletes the first \fIN\fP characters from the register.
+If \fIN\fP is negative, the break point is |\|\fIN\fP| from the end.
+.IP [/reg-exp/
+Set the count to the starting index of the regular expression in
+the register.
+Set the truth to whether the expression matches any of the register.
+.IP s\fIn\fP/reg-exp/replacement/
+.IP s\fIn\fP/reg-exp/replacement/g
+Perform a substitute command with semantics identical to the \fIs\fR command,
+but in the text of the register, not a line of the buffer.
+.IP C
+`Clean' the register: collapse each occurrence of `white space' in the register
+to a single blank, and delete initial and trailing white space.
+.IP {\|\fIS\fR
+Set the register to the value of the shell environment variable \fIS\fR,
+whose name may be terminated by a space, tab, newline or `}'.
+.PD
+.PP
+The registers can also be manipulated as decimal numbers.
+Numerical operations are indicated by a number sign `#'
+after the register name:
+e.g. `zx#+2'.
+It is an error to attempt to perform arithmetic on a
+register containing non-numeric text other than a leading minus sign.
+The numerical operations are:
+.IP a
+Set the value of the register to be the value of
+the address given to the command; e.g. `$za#a' sets register `a'
+to the number of lines in the buffer.
+.PD 0
+.IP r
+Set register \fIX\fR to be the first address
+given the command,
+and \fIX\fR+1 to be the second.  If \fIX\fR is `~', an error is generated.
+For example, `5,$zi#r' sets register `i' to 5, and
+register `j' to the value of `$'.
+`\fB.\fP' is unchanged.
+This command is usually used to pass addresses to a command buffer.
+.IP n
+Set register to the length of the addressed line.
+.IP \fB:\fIN\fR
+Set register to \fIN\fR.
+Scanning of the number stops at the first non-numeric character,
+not at the end of the line.
+.IP +\fIN\fR
+Increment register by \fIN\fR. `\-', `*', `/', and `%'
+decrement, multiply, divide, or modulo the register by \fIN\fR.
+.IP P
+Set register to the decimal value of the process id of
+.I qed.
+.IP =\fIN\fR
+(Or `<' or `>' or `!=' or `!<' or `!>'.)\ 
+Set truth flag to the result of the numeric comparison of the register
+and the number
+.I N.
+.PD
+.PP
+Several numerical operations may be combined in one command
+(and it is more efficient to do so when possible.)
+For example, `$zd#a\-3' sets register `d' to three less than the value
+of `$'.
+.RE
+.TP 5
+Z
+The zero command clears the current buffer.
+The contents, filename and all flags for the buffer are zeroed.
+The character after the `Z' must be a blank, tab or newline.
+.TP 5
+( $ )\|=
+The line number of the addressed line is typed.
+`\fB.\fR' is unchanged.
+.TP 5
+!\|<\s-2UNIX\s+2 command>
+The bang command sends the
+command line after the `!'
+to the UNIX shell to be interpreted as a command.
+Embedded newlines must be preceded by a backslash.
+The signals INTR, QUIT, and HUP are enabled or disabled
+as on entry to
+\fIqed\fP.
+At the completion of the command,
+if
+.I qed
+is in
+.I verbose
+mode, an `!' is typed.
+The return status of the command is stored in the truth flag.
+`\fB.\fR' is unchanged.
+.IP
+The
+command line
+is stored in register `U'.
+If a second `!' immediately follows the first,
+it is replaced with the uninterpreted contents
+of this register.
+Thus `!!' repeats the most recent bang command,
+and `!! \(or wc'
+repeats the command with an additional pipeline element added.
+.TP 5
+( 1 , $ )\|>\|<\s-2UNIX\s+2 command>
+The zap command is similar
+to the bang command,
+but the addressed lines become the default standard input of the command.
+The command is stored in register `U',
+as for bang;
+`>>' corresponds to `!!'.
+.TP 5
+( $ )\|<\|<\s-2UNIX\s+2 command>
+The crunch command is similar to the bang command,
+but the standard output of the command is appended to the current buffer
+after the addressed line, as though read with an \fIr\fR command
+from a temporary file.
+The command is stored in register `U'
+as for bang;
+`<<' corresponds to `!!'.
+`\fB.\fP' is left at the last line read.
+.TP 5
+( 1 , $ )\||\|<\s-2UNIX\s+2 command>
+The pipe command is similar to the bang command,
+but the addressed lines become the default standard input of the command,
+and are replaced by the standard output of the command.
+The command is stored in register `U'
+as for bang;
+`|\||' corresponds to `!!'.
+If the command returns non-zero status, the original lines are not deleted.
+`\fB.\fP' is left at the last line read.
+.TP 5
+( \fB.\fR )"
+The comment command sets dot to the addressed line, and ignores
+the rest of the line up to the first following double quote or newline.
+If, however, the character immediately after the double quote is
+a second double quote (i.e. the command is ``""''),
+the text which would normally be ignored is typed on the standard output.
+Special characters in the text will be interpreted, whether or not
+the text is printed,
+so to print a message such as ``Type \\bx'' requires the command
+``"\|"\|Type \\cbx''.
+Commented lines are used as labels by the
+.I y
+(jump) command.
+.TP 5
+%
+The register print command displays the name and value of all defined
+registers,
+followed by the \\p (`P') and \\r (`R') pseudo-registers,
+and the browse (`B') pseudo-register, if defined.
+.TP 5
+#
+The numeric register print command displays the name and value of all
+defined registers with numeric values.
+.TP 5
+( \fB.\fR+1 , \fB.\fR+1 )<newline>
+An address or addresses alone on a line
+cause the addressed lines to be printed.
+If the last address separator before the newline was `;',
+only the final addressed line is printed.
+A blank line alone causes the contents of the
+browse pseudo-register (described with the
+.I o
+command) to be executed.
+If the register is null, as it is initially,
+the newline command behaves as though the register contains
+`\fB.\fP+1p'.
+.PP
+.ul
+Special Characters
+.PP
+\fIQed\fP has some special character sequences with non-literal
+interpretations.
+These sequences are processed at the
+.I lowest
+level of input, so their interpretation is completely transparent
+to the actual commands.
+Whenever input from the user is expected, a special character can appear and
+will be processed.
+Special characters can be nested in the sense that, for example,
+a buffer invoked by `\eb' can contain a register invocation `\e\|z'.
+Backslashed escape sequences such as `\e\|(' in regular expressions
+are
+.I not
+special characters, so are not interpreted at input.
+The sequence `\e\|(' is left untouched by the input mechanism of
+.I qed;
+any special meaning it receives is given it during regular expression
+processing.
+The special characters are:
+.RS
+.IP \eb<bname>
+The `b' must be followed by a bname.
+When `\eb\fIX\fR' is typed,
+the contents of buffer \fIX\fR, up to but \fInot including\fP the last
+newline, are read as if they were entered from the keyboard.
+Typically, the missing newline is replaced by the newline which
+appears after the buffer invocation.
+Changing the contents of an executing buffer may have bizarre effects.
+.PD 0
+.IP \e\|B
+Equivalent to current buffer's bname.
+.IP \ec
+The sequence \ec is replaced by a single backslash,
+which is not re-scanned.
+The effect of the `c' is to delay interpretation of a special
+character.
+.IP \e\|f
+Equivalent to current buffer's file name.
+.IP \e\|F<bname>
+Equivalent to the file name in the named buffer.
+.IP \e\|l
+One line is read from the standard input up to, but \fInot including\fP
+the terminal newline, which is discarded.
+Note that the first invocation will read the remainder of the last
+line entered from the keyboard.
+For example, if a buffer is invoked by typing the line:
+.br
+.ti +5
+\ebxjunk
+.br
+the first \e\|l in buffer `x' will return the string `junk'.
+.IP \e\|N
+Equivalent to a newline.
+Primarily useful when delayed.
+.IP \ep
+Equivalent to the most recent regular expression used.
+.IP \e\|r
+Equivalent to the replacement text of
+the most recent substitute or join command.
+.IP \e\|z<bname>
+Equivalent to the contents of register `\e\|z\fIX\fR'.
+If the register changes during execution, the changes appear immediately
+and affect execution.
+If a `+' (`\-') appears between the `z' and the bname,
+the ASCII values of the characters in the register are
+incremented (decremented) by one before interpretation.
+If a `#' precedes the `+' (`\-')
+the contents of the register are numerically incremented (decremented).
+.IP \e"
+The sequence \e" means `no character at all'!
+It is primarily used to delay interpretation of a period
+that terminates an append, until the second or third time
+it is read (e.g. in loading execution buffers):
+the sequence \ec"\fB.\fP at the beginning of a line
+puts a period on the line which will terminate
+an append the second time it is read.
+.IP \e\*q[bfFlprz]\ 
+If an apostrophe
+appears between the backslash and the identifying character
+for one of the special characters `\eb', `\e\|f', `\e\|F', `\e\|l', `\e\|p',
+`\e\|r' or `\e\|z', interpretation is as usual except that
+any further special characters \fIembedded\fP
+in the buffer, register, etc. are \fInot\fP interpreted.
+Actually, any special character may be quoted, but in forms such as
+`\e\*q\|B', the quote has no effect.
+.RE
+.PD
+.PP
+A special character is interpreted immediately when it appears
+in the input stream,
+whether it is currently coming from
+the teletype, a buffer, a register, etc.
+(This includes characters read when typing a special character:
+`\e\*qb\eza', with register `a' containing the character `X',
+invokes the literal contents of buffer `X'.)\ 
+Thus, interpretation is recursive unless the special character
+is `\ec'.
+Special characters appearing in text processed in a command such
+as move, read or write, are \fInot\fP interpreted.
+If the backslash-character pair is not a special character
+from the above list, it is passed unchanged.
+Interpretation may be delayed using `\ec'; for example,
+if a `\ebx' is to be appended to a buffer for later interpretation,
+the user must type `\ecbx'.
+To delay interpretation \fIn\fP times, \fIn\fP c's must be placed between the
+backslash and the identifying character.
+In regular expressions and substitutes,
+a backslash preceding a metacharacter turns off its special meaning.
+Even in these cases,
+a backslash preceding an ordinary character is not deleted,
+unlike in \fIed\fP.
+For example, since the `g' command must read its entire line,
+a `\e\|zx' in a substitute driven by a global must be delayed
+if the contents of the register are to be different for each line,
+but since `\e&' is not a special character except to the substitute,
+its interpretation need not be delayed:
+.sp
+.in +5
+zA#:1
+.br
+g/\|\e$/ s\|/\|\e.xyz\|/\|\eczA \e&/p  zA#+1
+.sp
+.in
+globally searches for lines with a literal currency sign,
+and on each one substitutes for `.xyz' the contents
+of register `A'
+at the time of substitution,
+followed by a space and a literal ampersand,
+prints the result and increments register `A'.
+As a second example, the substitute
+.ti +5
+.sp
+s\|/xyz\|/\|\e\e\|N&/
+.sp
+replaces `xyz' with a newline followed by `xyz'.
+Note that the `\e\e\|N' is interpreted as
+`backslash followed by newline,'
+as the sequence `\\\\'
+.ft I
+has no special meaning in qed
+.ft R
+outside of regular expressions
+and replacement text.
+However,
+to match, say, `\e\e\|z' using a regular expression, it must be entered
+as `\e\e\ecz'.
+.PP
+.PP
+If an interrupt signal (ASCII DEL) is sent,
+.I qed
+prints `??' and returns to its command level.
+If a hangup signal is received,
+.I qed
+executes the command `S qed.hup'.
+.PP
+Some size limitations:
+512 characters per line,
+256 characters per global command list,
+1024 characters of string storage area,
+used for storing registers, file names and regular expressions,
+16 levels of input nesting,
+and 128K characters in the temporary file.
+The limit on the number of lines depends on the amount of core:
+each line takes 1 word.
+.SH FILES
+/tmp/q#, temporary;
+`#' is the process number (six decimal digits).
+.SH DIAGNOSTICS
+Diagnostics are in the form of `?' followed by a single letter code.
+If the diagnostic is because of an inaccessible file,
+the offending file name is also displayed.
+If input is not from the highest level (i.e. the standard input,
+usually the terminal), a traceback is printed, starting with the
+lowest level.
+The elements of the traceback
+are of the form ?b\fIXM.N\fR or ?z\fIXN\fR,
+where \fIX\fR is the buffer or register being executed when the
+error was encountered,
+\fIM\fR is the line number in the buffer and \fIN\fR is the character
+number in the line or register.
+The possible errors are:
+.PD 0
+.IP 0
+non-zero status return in \fI|\fR command
+.IP F
+bad bname for \e\|F
+.IP G
+nested globuf commands
+.IP N
+last line of input did not end with newline
+.IP O
+unknown option in the \fIo?c\fP command
+.IP R
+restore (\fIR\fR) command failed
+(file not found or bad format)
+.IP T
+I/O error or overflow in tempfile
+.IP Z
+out of string space; clear a few registers or file names
+.IP a
+address syntax
+.IP b
+bad bname in a \fIb\fR command or for \\b
+.IP c
+ran out of core
+.IP f
+filename syntax error
+.IP g
+nested global commands
+.IP i
+more than 52 files in initialization argument list
+.IP k
+bad bname in \fIk\fR command
+.IP l
+an internal table length was exceeded
+.IP m
+tried to move to an illegal place (e.g. 1,6m4)
+.IP o
+error opening or creating a file
+.IP p
+bad regular expression (pattern) syntax
+.IP q
+.I e
+with the current changed flag set,
+or
+.I q
+with any changed flag set
+.IP r
+read error from file
+.IP s
+no substitutions found
+.IP t
+bad \fIx\fR command data or single-case terminal
+.IP u
+no line for \fIu\fR command to undo
+.IP x
+command syntax error
+.IP w
+write error on file
+.IP y
+bad jump command (including popping the input buffer while scanning the label)
+.IP z
+bad register bname
+.IP |
+failure to create pipe for \fI<\fR, \fI|\fR or \fI>\fR command
+.IP #
+bad numeric register operation
+.IP $
+line address out of range
+.IP ?
+interrupt
+.IP /
+line search failed
+.IP [
+bad index in a register take or drop command
+.IP \e
+attempt to recursively append a buffer
+.IP !
+jackpot \(em you found a bug in regular expression matching
+.PD
+.PP
+.SH "SEE ALSO"
+qedbufs(1)
+.br
+A Tutorial Introduction to the ED Text Editor
+(B. W. Kernighan)
+.br
+Programming in
+.IR Qed :
+a Tutorial
+(Robert Pike)
+.br
+ed(1)
+.SH "U of T INFO"
+Written at U of T,
+based on several incarnations of
+.I ed,
+with contributions from
+Tom Duff, Robert Pike, Hugh Redelmeier and David Tilbrook.
+.SH BUGS
+The changed flag is not omniscient; changing the contents of
+the file outside of
+.I qed
+will fool it.
+.br
+Xform \fIcould\fP work on single-case terminals, but backslashes
+become very confusing for the user.
+.br
+On the PDP-11, numeric registers are 16-bit integers, but the
+count is a 32-bit integer.
-- 
cgit v1.2.3