QEF home page

Appendix D: Q-Tree Command Summaries

The Guide's Table of Contents Previous Chapter Bottom Of Page Next Chapter

Tool entries in the x-qef database.


The following descriptions are extracted from the x-qef database.
adjmat produce adjacency matrix
arccentre compute the centre of an arc
artimes set last modification times for files of an archive
arupdate update an archive library
ascii print a table of the ASCII character set
bfsic build file system integrity check and db maintenance
bp deliver source code boiler plate
c% cush link that translates _%_ in command
cancreat check if file can be created
cc_g gcc interface that eliminates gratuitous warnings
cc_z cc interface that eliminates gratuitous messages
cerrs parse input extracting cc errors and warnings
chkfile check all files exist killing argument pid on failure
chstat change the status of files named in list or arguments
cleanilog clean up an instal.log file
clrstr output terminal clear string in readable form
clump convert file:lineno input to ranges
cmdcmp compare the outputs of two commands
com compile or process file using embedded command
commw print input terms not in dictionaries
company output company information
condln link or copy file1 to file2
confvrs create or compare qvrs config file
contax output selected contax database entries
conv convert input characters to readable form
count produce numbers
cpifdif compare new and old and copy if different
ct cut input into cut file
cush could (could not) use shell interface
depsmap create file mapping suffixes to mkdeps file
detox remove toxic waste normally found in dos files
dirlist produce list of all directories for input file list
dirname output directory pathname for files
dirsetup set up a directory from prototype file
divide split files at specified pattern
dmpdeps dump or test deps object
dosmap change Unix paths to DOS paths
double output differing lines of files separated by tab
dry run dhrystone tests
elimso eliminate n/troff inclusions
environ list args, uid/gid, cwd, open files, env, and ignored sigs
envset output environment setting commands
envstd list arguments, open files and ignored signals
fcmp compares new and old
fdate output formatted date string
fexists output file names that match specified attributes
ffill fill in suppressed fields
filelist maintain a file list and their collective modification time
finclude output file resolving includes
finda find and replace Ada variables
findc find and replace C variables
findf find and replace tabbed fields
findw find and replace words
fixflist remove non-existent files from a file list
flcomm comm(1) like but columns put into files
fnd find a command
fndstr find a string in a file and output offset
form text formatter and macro processor
fparens check bracket, brace and double quote balancing in form input
ftest test argument file attributes
g process go files
go detach a command
goes view or remove jobs from go message files
gomonitor display josh halt files as updated and other files
gotstr output names of files that contain argument string
grpsort sort groups of lines specified by ranges
hhmmss output a banner of the time
hoff hell of a lot faster than nroff
howto output selected howto information
incls dynamic dependency tracker
instal meticulously install a file and audit it
instdir install a directory
instfls install files, but only if necessary, according to script
jlines join up selected lines
josh a job shell
kdbm extract from or add to DBM database
l list files in columns
lash long argument list shell interface
lc list files by type in columns
lcmp compare two files
ldbm extract from or add to DBM line database
ledmp display current lefile values
leset set up line editing keyfile
liborder process nm of a library to produce dependency graph
libs output information on libraries used by the named files
lines print first N and last M lines
linked list files with multiple links
lls ls for input files with selected fields output
lninsert replace characters in master by lines from source
lntree create tree of symbolic links to input file list
man3db apply trg script to selected items from man3 TIPs database
manprep prepare manual sections for qef info tool
mimk issue updating commands according to a dependency script
mkalltraits run mktraits on remote hosts
mkddt create ddt declaration
mkdeps compile deps scanner file
mkerrs process error databases to produce other source
mkopts create options header file
mkqtree set up new qef tree
mkquete produce manual section index
mksolib create shared library externs list
mktraits compile traits files
mkvernum create or change version string
mnfadd add a new manifest to manifest database
mnfchk check manifest database for syntax and consistency
mnfcmp compare two manifests
mnfdb output manifest database release information
mnfdel delete releases from manifest database
mnfput output a manifest or manifest database
necho echo with escape interpretation
numb produce numbered lines
olex lexical analyser builder
p4files list perforce files for the current root
p4mnf list p4 files for the current root
pa output, list, or delete cut files
parmsdb output parms database in variety of formats
pathclash produce list of duplicated executables in path
pathto map argument file to special directory
pdirs directory stack manipulation for shells without pushd
ph output phone numbers for selected contax database entries
putifdif copy input to output file if different
qconfset add variable setting to the conf.vrs file
qd shell alias/function to chdir using selected qdsrv database entry
qdchk check host's qdsrv database entries
qdid assign qdsrv ident and/or bind to path
qdmgt general qdsrv management interface
qds select and print entries from qdsrv database
qdsrv qef project database server
qdupd add path to qdsrv database
qed somewhere between a line editor and a command interpreter
qedbufs output qed save file structures
qef the driver
qefdirs qef script generator for multiple directories
qefgui run the qef qui
qefinfo run the qef info tool
qefpp the qef macro processor
qenv output environment variables in sorted usable form
qfunc output selected qfunc function/alias file
qgdiff graphical file difference viewer
qhost qtree host server
qhy report why a target was rebuilt
qlex interface to lex
qmsdev Microsoft Developer's Studio project file generator
qmsg send a message or mail to designated users
qremote run a command on a remote host (if necessary)
qrep another grep
qsg the primary qef script generator
qsgcomp compiles a qsg script to object
qsgdump dump a qsg object file
qsh qef shell command interpreter
qtreeinfo output information on $QTREE and its directories
quete list x_db topics and quete.db entries that match patterns
qvrs process the qvrs files
qvrsdmp process qvrs binary file
qvrsexpr evaluate and output qvrs expressions
qyacc interface to yacc
r90 reflect lines around diagonal
rc windows resource compiler
rcslocks report the RCS locked files in a directory
realdir output real directory name for argument directory
recur execute a command repetitively
rep another grep
resort build new output in order specified by input
revl reverse input lines
rls recursive list of files
rmlist remove files named in input
rmnotnamed remove all files not named by arguments
rmwhite output rpl script to remove redundant white space and newlines
rootvrs create or modify the root.vrs file
rotf select fields of input lines for output
rpl replace, print, or delete named lines
rtabs align fields by inserting padding
samefile check if two paths refer to same file
sdba output statistics about sdbm database
setbytes set specified offsets to strings
sfdchk check strfix dictionaries for valid patterns
sfsic source file system integrity check and db maintenance
shfix process input file incorporating output of embedded commands
shuffle shuffle input lines and output
sls source path ls
snm standardized nm output
srclist check the srclist._ file
strfix replace variables according to replacement dictionary
sttyek set or display saved stty erase and kill chars
subdist create sub-distribution from master file lists
summarize summarize selected fields
sumup output summations of selected input fields
suprep suppress repeated fields
sysnm output symbolic system name or check if it matches arguments
system output system name or check if it matches arguments
tabrpl replace tabs by spaces or vice versa
tchown change ownership and mode according to a template
tdbkeys list TIPs database index keys and/or files
tdbm create TIPs key files
tdbrg apply trg program against selected TIPs DBM database entries
ted TIPs file editor
termfnd check if termcap/terminfo entry exists
termsa list all Ada variables in files
termsc list all C variables in files
termsf list all tabbed fields in files
termsw list all words in files
tf output name of non-existent comma file
tildes convert between symbolic and real character representations
timeout execute a program with a time limit
tlist formated listing of TIPs data base files
tmkprof create new TIPs data base profile
topolsrt topologically sort input
touchfiles list or create touch files
tprof output TIPs profile in various formats
traits output traits table
transl translate input fields
treedirs mkdir selected or all sub-directories of a qef tree
trg template driven TIPs report generator
trgdmp print trg object file
trgmk compile trg script
tscan interactive TIPs data base scanner
tstrhash test strhash hashing
typset interface to typesetter and printing packages
untouch set file times
upd update conventionally named versions of files
upto print selected lines from named files
vcc create, compile, link, and remove version string source file
vci version control system interface
vernumcomp compress the mkvernum database
wcci windows c compiler interface
whats whats 2 + 2
wmode write-protect files
wordidx output input lines followed by lines indicating word count
wot output embedded sccs id strings
x-contax contax use and data bases eXplanatory D.B.
x-eml form eml macros eXplanatory D.B.
x-form form macros and syntax eXplanatory D.B.
x-html html qsg library eXplanatory D.B.
x-ldeps deps library eXplanatory D.B.
x-ldtree x_db database describing routines of the -ldtree library
x-lledit ledit library eXplanatory D.B.
x-lqvrs qvrs library eXplanatory D.B.
x-ltc tc library eXplanatory D.B.
x-ltips tips library eXplanatory D.B.
x-man the -man macro set eXplanatory D.B.
x-qed qed commands and facilities eXplanatory D.B.
x-qef QEF facilities and tools eXplanatory D.B.
x-qefdirs qefdirs eXplanatory D.B.
x-qefeg prototype qef files eXplanatory D.B.
x-qefgui qef graphical user interface eXplanatory D.B.
x-qefpp qef preprocessor controls and macros eXplanatory D.B.
x-qfsic file system integrity (fsic) package eXplanatory D.B.
x-qmisc Q-Tree miscellany eXplanatory D.B.
x-qproc software process procedures eXplanatory D.B.
x-qsg qsg and its support library eXplanatory D.B.
x-qvrs qvrs variables, facilities, and files eXplanatory D.B.
x-ted ted the TIPs editor eXplanatory D.B.
x-trg TIPs trg functions eXplanatory D.B.
x-tscan tscan facilities and commands eXplanatory D.B.
x-xfig xfig qsg library eXplanatory D.B.
x-zr qed function library eXplanatory D.B.
x_db x_db database front end
xdbmk create an x_db data base
xdbs list all or specified x_db databases or all their topics
xfinterp process -x flag outputs
xtty convert stty(1) output to full explanations
younger test if files younger than specified time
zfill zero fill digit string


	 adjmat  produce adjacency matrix
		adjmat reads the argument files (defaults to the standard
		input) and produces an adjacency matrix of the relation-
		ships expressed by the input lines.

		Input lines consist of white space separated words, the first of
		which is taken as the label.  The balance of the line's words
		are the nodes to which the label is adjacent.

		The output is an adjacency matrix with adjacencies marked with an X.
		See adjmat(1) for an example.

		See also: adjmat(1) adjmat(-x)

	 arccentre  compute the centre of an arc
		arccentre computes the centre point of an arc for use by Arc(x-xfig).
		The arguments are three points expressed in xfig(1) units,
		and the output is two floats expressing the centre point.

		If the points are colinear (i.e., not an arc), arccentre
		aborts with a suitable diagnostic output.

		See also: arccentre (1) arccentre (-x) Arc(x-xfig)

	 artimes  set last modification times for files of an archive
		artimes reads the argument ar(1) file and for each member file, sets
		the modification time of the corresponding file to modification time
		as stored in the archive.

		This is used to create realistic modification times for files that are
		extracted from object libraries for versions of make(1) that do not
		understand how to process archive libraries.

		artimes is unnecessary if ar supports the -o flag.

		See also: artimes(1) artimes(-x) ar(1)

	 arupdate  update an archive library
		arupdate is used as an interface to ar(1) in library building scripts.
		arupdate is used instead of ar as it is an interface is based on a
		specification of what should be in the library, from which it
		determines what actions to take to bring the library up-to-date.

		arupdate's arguments are interpreted to create a list of the
		files that are to be part of the archive.  The actual arguments may
		be files to be included, files that contain the names of files to
		be included, or the names of other archives, some or all of whose
		elements are to be included.

		Given this member list, arupdate checks the archive to determine
		the files that need to be removed (i.e., in archive but not the list)
		the files that need to be replaced (i.e., existing file's time-stamp
		is not equal to that in the archive), and the files to be added
		(i.e., in the list but not in the archive).

		Note:	A file named in the argument generated member list need not
			exist, provided it is already in the archive.

		arupdate then invokes ar once to delete member files that are no longer
		part of the library or will be re-added and a second time to add
		in the new or replacement member files.

		It will then remove all the files that have been added (other than
		those extracted from other archives) unless the -k flag has been
		specified.

		arupdate also supports an option to add a mkvernum generated
		version file to the archive.

		Note:	If the -V module is specified, the .c module that is created (i.e.,
			_vmodule.c) is compiled using the _F_mkvernum_cc[module]
			or _F_mkvernum_cc flags.

		See also: arupdate(1) arupdate(-x) ar(1) mkvernum _F_mkvernum_cc(x-qvrs)

	 ascii  print a table of the ASCII character set
		ascii outputs the table of ASCII characters in a variety of formats,
		as in:

		    |000 nul|001 soh|002 stx|003 etx|004 eot|005 enq|006 ack|007 bel|
		    ...
		    |170  x |171  y |172  z |173  { |174  | |175  } |176  ~ |177 del|

		Options exist to produce the hexadecimal or decimal values, of the
		values for selected characters, as in:

			% ascii a.9
			a	141	097	61	lx
			.	056	046	2E	p
			9	071	057	39	n

		See ascii(-x) for list of type keys used for the fifth column of
		the above output (e.g., 'l' for lower case, 'p' for punctuation).

		See also: ascii(1) ascii(-x)

	 bfsic  build file system integrity check and db maintenance
		bfsic is used to compare the lists of existing installed and object
		file systems against the FSIC database inst.fl, objs.fl, deviates.fl,
		except/<sysnm>.fl, and <Q>/lib/bfsic.cf.

		Typically bfsic is used in the fsic(x-qsg) script to create the
		,p.errors, ,i.tmps, and ,o.tmps files, which in turn are used
		to correct the file systems and database.

		Note:	The fsic directory is typically in @QefAdm/fsic in the
			root directory.

		See also: bfsic(1) bfsic(-x) FSIC(x-qfsic) inst.fl(x-qfsic)
			objs.fl(x-qfsic) deviates.fl except/<sysnm>.fl <Q>/lib/bfsic.cf

	 bp  deliver source code boiler plate
		When bp is invoked with an argument X, it searches for a file called
		Bp.dir/X in the directories named by $PATH.  If such a file is found
		and it begins with the sequence `#BP' followed by a tab, the file
		is copied to the standard output, after replacing certain `%%'
		sequences with run-time values (e.g., the date or user's name) or
		interpretations.

		bp is used to retrieve and output prototypes of various files, text
		or code segments.

		If bp is invoked without arguments, it outputs a list of all the
		bp files available.

		howto is a link to bp that searches for Howto.dir/X files.

		Note:	Many of the boiler plates relate to the qef system.
			See x-qefeg.

		See also: bp(1) bp(-x) howto qfunc new-bp(x-qmisc) New-Bp(x-qefgui)

	 c%  cush link that translates _%_ in command
		c% is an alias for cush that assumes the -% flag to
		save typing six characters.

		For a full description see cush(1).

		See also: cush c%(1) c%(-x) cush(1)

	 cancreat  check if file can be created
		cancreat checks that the argument file can be created, or
		opened for writing (if it already exists).

		The exit status is 0 if the requested access is permitted
		or possible.  Otherwise it is -1.

		If -d specified, then check is that files may be created
		in the directory file.  If file is not specified, -d is
		assumed and file defaults to the current directory (i.e., .).

		See also: cancreat(1) cancreat(-x) ftest test(1)

	 cc_g  gcc interface that eliminates gratuitous warnings
		cc_g is a link to cc_z that eliminates the numerous messages
		generated by gcc that are of little or no value or cannot be resolved.
		The messages to be eliminated are those matched by regular expressions
		associated with cc_g in the file <qtree-root>/lib/cc_z.cf.

		See also: cc_z cc_z(1) cc_z(-x)

	 cc_z  cc interface that eliminates gratuitous messages
		cc_z and its links are interfaces to the standard C compiler that
		filters cc output to eliminate various gratuitous messages such as
		the copyright notices and warnings that cannot be resolved.  The
		file <qtree-root>/lib/cc_z.cf should contain lines that indicate the
		real compiler program to be used and regular expressions to be
		applied. That file contains comments that describe its contents in
		more detail.

		See also: cc_g cc_z(1) cc_z(-x) cc_z.cf

	 cerrs  parse input extracting cc errors and warnings
		cerrs reads its input, extracts C compiler diagnostic messages,
		converts them to a canonical form of file, `:', lineno, `:', and
		message, optionally converts file names to canonical forms using a
		mapping mechanism, and outputs the result.  This allows one to feed
		the output of a large qef or make session to cerrs and get a
		usable list of the diagnostics.

		See also: cerrs(1) cerrs(-x)

	 chkfile  check all files exist killing argument pid on failure
		chkfile checks that its argument files exist or are writable (if -w
		specified. If any do not exist (or unwritable), it sends a SIGTERM to
		the argument pid process and exits with status -1.  If the pid
		argument is not specified, chkfile just exits with a diagnostic
		message and a non-zero status.

		If all the argument files exist, chkfile exits silently with status 0.

		chkfile is used within shell scripts to abort the script if a check
		file is removed as in:

		              touch CHK$$
		              echo To terminate this program, remove CHK$$
		              while true ; do
		                      : commands ...
		                      chkfile -p $$ CHK$$
		              done

		See also: chkfile(1) chkfile(-x) ftest test(1)

	 chstat  change the status of files named in list or arguments
		chstat is a combination of chmod(3), chown(3), and chgrp(3) that
		processes the files named in argument files or in the standard input.

		chstat is useful for processing large numbers of files named by
		some pipe line or file.

		See also: chstat(1) chstat(-x) tchown wmode chmod(1) chgrp(1) chown(1)

	 cleanilog  clean up an instal.log file
		Whenever instal(1) is run, if the qvrs(1) variable @InstLog is set,
		instal appends an audit trail record to the @InstLog file (usually
		instal.log at the base of the Object tree).  This audit file can grow
		substantially and may contain many obsolete records.  cleanilog may be
		used to eliminate obsolete records and optionally remove records
		that refer to non-existent files from an instal audit trail.

		To update the current tree's @InstLog file, purging references to
		non-existent files, use:

			cleanilog -Iuvp

		See also: cleanilog(1) cleanilog(-x) instal InstLog(x-qvrs)

	 clrstr  output terminal clear string in readable form
		clrstr writes (to the standard output) the string of characters that
		will clear the screen of the terminal as specified by the term
		argument (default $TERM).

		By default the string is output in a printable form (e.g., ESC
		(octal 033) shown as "\33", newline output as "^J").

		The -n suppresses this translation and the -q flag outputs
		the string in as a qed string.

		See also: clrstr(1) clrstr(-x) qed clear(1)

	 clump  convert file:lineno input to ranges
		clump reads its input, which should be a series of lines similar to
		that produced by qrep's -n flag (i.e., contain the file name, a
		colon, and the line number, a colon, and the contents), as in:

			file:14:This is the first line of a clump
			file:15:This is the second line.
			newfile:200:This is a single line clump

		This is also the form of output produced by many other programs such as:
		lines, findc (et al), and rpl.

		Groups of input lines that refer to a series of sequential lines are
		output as "clumps".

		Clumps are output as the file name, a colon (':'), the line number
		of the first line.  If it is a multi-line clump, the line number
		is followed by a comma and the number of following lines in the clump.

		For the above input, the output would be:

			file:000014,1:
			newfile:000200:

		This output may be input to rpl with the -sa flags to get
		the addressed lines.

		See also: clump(1) clump(-x) rpl qrep

	 cmdcmp  compare the outputs of two commands
		cmdcmp compares the output of a command to the output of another
		command, the contents of a file or the standard input.  It can also
		compare the contents of a file to the contents of another file or the
		standard input, although that is just duplicating the capability of
		cmp(1) or fcmp.

		cmdcmp was created to circumvent the problems of the ambiguity of the
		exit status of a pipeline and the problems associated with the
		management and removal of temporary files.

		See also: cmdcmp(1) cmdcmp(-x) fcmp cmp(1)

	 com  compile or process file using embedded command
		com extracts specially identified command lines, called com lines,
		from its argument files, processes those lines to replace special
		strings by parts of the argument file name or extracted from the
		qvrs(1) files, and interprets the resulting line as a shell command.

		A com line is a line within the first 1024 characters of the file that
		contains the string `/*^' or `/*%'.  The balance of the line is
		processed to replace `^' characters followed by special strings by
		special interpretations (as listed by com -X).  The resulting line
		is then executed as a sh(1) command.

		<qtree-root>/lib/comlines contains the com macros.

		See also: com(1) com(-x) qvrs

	 commw  print input terms not in dictionaries
		commw reads its input and outputs all terms in the input that are
		not in one of the dictionaries.

		The input file and dictionaries must be in the order normally
		generated by termsw.

		A dictionary term is equivalent to an input file term if the
		dictionary term is equal to the lower case version of, or the
		unpunctuated version of the input file term.

		commw typically used to prepare a replacement dictionary for findw
		as it understands the punctuation, accents, and capitalization rules
		of that program.

		Note:	commw was originally created to compare words found by
			termsw against dictionaries to determine words to be
			corrected.  Given the availability of fairly good versions
			spell(1) one is probably better of using spell to
			find terms that are questionable and then use that list
			to create the findw replacement dictionary.

		See also: commw(1) commw(-x) findw termsw <Q>/lib/words

	 company  output company information
		company uses the information specified in the -i specified strfix
		dictionary company-info (defaults to ~/.qtree/company.cf or
		<Q>/data/company.cf) and outputs that information according
		to the format specified by the -f file or format.
		The result is written to specified outfile or the standard output.

		Note:	bp also consults the company info file.

		See also: company(1) company(-x) bp <Q>/data/company.cf ~/.qtree/company.cf

	 condln  link or copy file1 to file2
		condln, given two argument files f1 and f2, ensures that f1 is
		linked or copied to f2, even if f2 already exists.  condln is
		used instead of ln(1) as that program fails under a number of
		conditions that condln avoids (e.g., f2 exists or is on a different
		file system).

		In summary, condln tries to ensure that file2 is either a link (hard
		or symbolic) to file1 or is a link to a copy of file1 or is itself a
		copy of file1.

		See also: condln(1) condln(-x) ln(1) mklink(x-qsg)

	 confvrs  create or compare qvrs config file
		The second file processed by qvrs(1) is the file that the user
		provides or names to set configuration parameters.  The actual
		file used is based on @ConfVrs or searching for conf.vrs or
		confdefl.vrs in the directories named by @?ConfVrsPath.

		confvrs provides a number of services with respect to the current
		config file and the default version.  The default behaviour is to
		output the name of the current config file and the names and values
		for the variables it sets.

		Other facilities (selected by flags) show the variables and values
		for the default config file (-D), show the differences between the
		real and default config files (-d); and copy the default config file
		to conf.vrs (-o).

		See also: confvrs(1) confvrs(-x) qvrs qconfset mkqtree ConfVrs(x-qvrs)
			ConfVrsPath(x-qvrs) conf.vrs(x-qvrs) confvrs/(x-qvrs)
			confdefl.vrs(x-qvrs) confdefl-eg(x-qefeg)

	 contax  output selected contax database entries
		contax is a TIPs application program that scans the specified contacts
		database and outputs selected entries in the selected format.

		As such this program can be used for a variety of applications.  For
		example, it can retrieve and display the phone numbers and/or
		addresses for selected names.  It can produce form letters in which it
		fills in the title, affiliation, address, and salutation for selected
		names and/or keywords.  Using the keyword search facility it can be
		used for distribution lists to drive electronic mailings.  contax
		selects items from the specified contax data base, and outputs the
		selected entries in the specified format.

		See also: contax(1) contax(-x) ph x-contax TIPs

	 conv  convert input characters to readable form
		conv outputs a line, such as the following, for each character
		(excluding the nulls) in the arguments.

			Character x : Octal 170 Decimal 120 Hex 78 Binary 01111000

		If no arguments are given, stty(2) is used to set the terminal into raw
		mode (so as to get all the bits and to suppress any interpretation)
		and a single input line is read, up to the first newline, carriage
		return or ctrl-d.  Then lines of the above form are output for each of
		the characters in the read line.  The line for the terminating
		character is not output, unless it is the only character in the input
		or the -e flag is given.

		conv's major use is to determine what all those strange keys on a
		keyboard actually deliver.  It is frequently used when designing a
		leset file or a qed terminal file.

		See also: conv(1) conv(-x) qed leset

	 count  produce numbers
		count outputs the integers from a specified start (defaults to 0)
		to a specified stop (defaults to 32767) in using the specified
		increment (default 1 or -1 (if the start > stop).

		A printf(3) format can be specified for the output.

		count was added to the QEF product at a client's request, for
		what I know not, but it can be useful.

		See also: count(1) count(-x)

	 cpifdif  compare new and old and copy if different
		cpifdif is a very fast implementation of

			cmp -s new old || cp new old

		without the complications that arise due to cmp's exit codes.

		It is used extensively to install new versions of a file only
		if the file is changed.

		See also: cpifdif(1) cpifdif(-x) cmp(1) putifdif cmdcmp

	 ct  cut input into cut file
		ct copies its input files or the standard input into a temporary
		file in the directory named by $CTDIR or ~/.qtree/ctdir.

		The companion program pa can be used to retrieve the saved file
		by explicit basename or an age index (0 for the youngest, 1 for
		the next youngest, etc.)

		See also: ct(1) ct(-x) pa

	 cush  could (could not) use shell interface
		cush simply runs the argument command, which should consist of a
		program and the arguments to that program.  Flags and options allow
		command line specification of the setting and unsetting of environment
		variables, redirection of I/O, chdirs, special process management, and
		process attributes often not available or not easily done using the
		standard shells.

		One of the more important cush options is to facilitate the saving
		of the input in a temporary file, the name of which is inserted into
		the argument command.  This facilitates using commands that require a
		file and cannot process the standard input. cush is also used to
		do redirection of I/O in command processors which do not support I/O
		redirection, when the redirection cannot be expressed in the current
		shell's context (i.e., on a remote machine or as a different user), or
		when doing so imposes an additional overhead (e.g., forking a shell).

		cush has a -E flag that allows the specification of an envset
		environment set to be applied before executing the program.  This
		option can thus be used to change $PATH or to specify an environment
		on a remote host as is done by qremote.

		Note:	c% is a link to cush that converts any "_%_"s in the
			argument command to spaces.  It's actually equivalent
			to cush invoked with the -% flag.

		See also: cush(1) cush(-x) envset qremote c%

	 depsmap  create file mapping suffixes to mkdeps file
		depsmap processes the argument files which must be dependency state
		tables and description files as produced by mkdeps.  The Class name,
		Description field, and the Suffixes list for each file are extracted
		and saved.  Once all the files are processed, depsmap writes the
		resulting lists to the output file ofile (defaults to the standard
		output).

		The resulting file is used by other programs to map a file to the deps
		class to be used to process the file.  The depsmap output file is
		normally installed as <qtree-root>/lib/deps/deps.map.

		See also: depsmap(1) depsmap(-x) mkdeps dmpdeps incls deps.map

	 detox  remove toxic waste normally found in dos files
		detox removes any carriage returns before a new line and a
		control-z at the end of its input.  Alternatively it can insert
		the carriage returns and control-z.

		An option is provided to change files in situ.

	 dirlist  produce list of all directories for input file list
		dirlist reads pathnames from its input files and outputs a unique
		sorted list of all the directories involved in the input pathnames.

		Given the path name dir1/dir2/file, dirlist would output:

			dir1
			dir1/dir2

		dirlist is used to produce the list of directories that may have
		to be processed to deal with named or listed files.

		See also: dirlist(1) dirlist(-x) dirname(1)

	 dirname  output directory pathname for files
		By default, dirname outputs the directory file for each
		argument path or, if the -f flag specified, for each file
		name contained in the argument file.  If no file arguments
		are given, the file names read from the standard input are
		processed.  If any -p, -d, or -l flags are specified, the
		selected file name parts (the simplified pathname -p, the
		directory name -d, and the leaf name -l) are output in
		that order, separated by tabs.

		The named files are reduced to their simplest form by
		removing redundant parts of the name (e.g., ``/./'',
		``/X/../'').  the resulting path is then split into the
		directory and file name parts.

		See also: dirname(1) dirname(-x) basename(1)

	 dirsetup  set up a directory from prototype file
		The input files to dirsetup consist of lines specifying directories,
		files and their contents, and annotations.  When dirsetup processes
		such a file, dirsetup creates the specified directories and files in
		directory dir.  dirsetup will not overwrite any existing file unless
		the -o flag is specified.  Any annotations are output to the standard
		output.

		dirsetup files are usually used to define file systems for special
		applications such as the qef tutorials or a generic qef administered
		project.

		In the absence of any arguments or flags, dirsetup lists the currently
		available dirsetup files.

		Currently the dirsetup databases are:

			dotqtree	set up for a user's .qtree directory
			fsic		files of the file system integrity check
			miniproj	files for a minimal qef project
			newproj		infrastructure files for a qef project
			qeftut1		qef tutorial set # 1
			qeftut2		qef tutorial set # 2
			qeftut3		qef tutorial set # 3
			qegappl		example qef application package
			qeglibeg	example qef library set up and mgt.
			qegqsl		example of project specific qsglib

		See also: dirsetup(1) dirsetup(-x) new-dirsetup(x-qmisc)
			dirsetup-sets(x-qefeg)

	 divide  split files at specified pattern
		divide reads the argument files (defaults to the standard
		input) and splits the output into files named prefix001,
		prefix002, ... (prefix defaults to ``x'').

		The files are split at the <num>th line if no linemarker
		is given.  Otherwise, the files are split at the first
		line after (if -a specified) or the last line before (if
		-b specified) a line that matches the regexp(x-qmisc) pattern
		specified by the -p flag.

		See also: divide(1) divide(-x) split(1) regexp

	 dmpdeps  dump or test deps object
		Dependency files are created by the mkdeps program.  They contain a
		state table to find and extract embedded dependencies such as the
		`#include' of the C programming language plus information used to
		convert an embedded `included' symbol to a file.

		The dependency suffix map file, deps.map, is used to map file names to
		deps files.  Basically it contains the names of the supported deps
		files and patterns that match the files that it processes.

		dmpdeps outputs readable representations of either a selected
		dependency file or the dependency suffix map file.

		Some useful commands:

			dmpdeps -m		# show list of current deps files
			dmpdeps -cc		# dump information about c deps file
			dmpdeps -s -c tex	# dump source for tex deps file

		See also: dmpdeps(1) dmpdeps(-x) mkdeps incls depsmap deps.map

	 dosmap  change Unix paths to DOS paths
		dosmap reads its argument files (defaults to the standard input) and
		copies what was read to ofile (defaults to the standard output),
		converting any strings embedded in ``%%''s to their DOS path names as
		mapped by roots.map files.

		See also: dosmap(1) dosmap(-x) dospath(x-ldtree) roots.map

	 double  output differing lines of files separated by tab
		double reads lines from its two input files in parallel.  If the input
		lines differ, they are output as a single line with a separating tab.

		double is commonly used to produce a replacement dictionary for other
		tools such as findf(1).

		See also: double(1) double(-x) comm(1)

	 dry  run dhrystone tests
		dry runs the dhrystone tests which are an attempt to measure sure
		the performance of the host machine.  For example:

			% dry -l 5hk
			Dhrystone(1.1) time for 500000 passes = 4
			This machine benchmarks at 125000 dhrystones/second

		As might be deduced this is an old program on an old platform.

		Upping the number of loops may increase the accuracy.

		See also: dry(1) dry(-x)

	 elimso  eliminate n/troff inclusions
		elimso is used to eliminate n/troff ".so" commands from
		the input by replacing the containing line by the named
		file.  Also supported is the facility to incorporate the
		output of shell commands.

		It is provided for use by typset.

		Note:	The -S option specifies that the qvrs variable @SrcPath
			directories are searched for files to be included.

		See also: elimso(1) elimso(-x) typset soelim(1) qvrs

	 environ  list args, uid/gid, cwd, open files, env, and ignored sigs
		environ outputs the argument list (including the first argument) in an
		unambiguous form (using `\ddd' to represent unprintable characters),
		lists the file descriptors that are open, the signals that are not
		SIG_DFL, the real and effective uids and gids, the umask setting, and
		the environment variables.  The output is written to /dev/tty to
		ensure its visibility.

		environ was created to test that programs were setting up the correct
		signals, arguments, and files before forking and execing another
		program.  This is usually done by moving the program of interest (i.e.,
		the program that will be exec'ed) to a temporary location, linking or
		copying environ to the old program name and running the parent program.
		Alternatively one may be able to link environ to the program name
		in an earlier directory of the $PATH.

		See also: environ(1) environ(-x) envstd

	 envset  output environment setting commands
		envset is used to extract a named set of environment variables settings
		and unsettings specified in ~/.qtree/envset.cf, <qtree-root>/data/envset.cf,
		and <qtree-root>/lib/envset.cf).

		envset outputs the selected sets as a series of sh or csh commands
		to perform the various settings/unsettings.

		envset -x explains the syntax of the envset file.

		It is convenient to set an alias or shell function Ev to facilitate
		running envset and interpreting its output.

		In the csh use:

			alias Ev 'eval `<qtree-root>/bin/envset -cNQ \!*`'

		In sh or one of its clones, use:

			Ev () {
				eval $(<qtree-root>/bin/envset -NQ $*)
			}

		Note:	There is a qfunc option Ev which will deliver the
			appropriate setting.

		So then Ev EnvSet will changes the current shell's environment to that
		specified by the argument.

		The fully rooted path is used so that $PATH does not need to be set
		correctly for Ev to work.  The -Q flag will set $QTREE to the
		the program's path name minus "/bin/envset" (i.e., <qtree-root>).

		Note:	qremote executes cush with the flag -E envset, where
			envset is usually the value of @QremoteEnv as extracted
			from the root.vrs file.

		Note:	cush, josh, and qsg all have a -E flags that selects an
			envset for interpretation before executing the argument command.
			QremoteEnv specifies the envset to be loaded on the remote
			system, actually done via cush.

		See also: envset(1) envset(-x) cush josh qsg qfunc $ENVSETS
			qremote QremoteEnv(x-qvrs)

	 envstd  list arguments, open files and ignored signals
		envstd is a link to environ.  environ lists its arguments, open
		files, real and effective uids and gids, its umask setting and its
		environment variables.  environ writes its output to a file
		(usually /dev/tty) opened specifically to ensure its visibility.
		When environ is invoked as envstd, the various outputs can be
		selected by flags and the output is written to the standard output.

		See also: envstd(1) envstd(-x) environ

	 fcmp  compares new and old
		fcmp is a link to cpifdif and is equivalent to specifying a -n or -N
		to that program.  Basically, fcmp compares the files new and old and
		exits with status 0 if they are identical, and 1 otherwise.

		fcmp is basically the same as cmp(1) except faster, consistent, and
		providing some important options.

		See also: fcmp(1) fcmp(-x) cpifdif cmp(1)

	 fdate  output formatted date string
		fdate formats a specified time -- defaults to the current time --
		according to a specified format.  The format argument consists of `^'
		followed by a single letter to select the element of the time to be
		output.  For example:

			fdate '^a ^h ^d ^T ^c^y'

		would output:

			Mon Jan 31 05:48:21 2000

		The command:

			fdate -X

		will output the format keys and their descriptions.

		fdate predates the extension of date(1)'s extension to provide
		similar functionality, however, date is limited to displaying the
		current time, whereas fdate can be used to output the date for
		an arbitrary time such as the time stamps stored in qmkhist._ files.

		See also: fdate(1) fdate(-x) date(1)

	 fexists  output file names that match specified attributes
		fexists is used in the FSIC package qef script to filter a list of files
		to remove those that aren't empty.  This is used in a pipeline with
		rmlist to remove the empty files.

		fexists can also be used to select input paths that are or are not
		files, directories, have a specified mode, have been modified within
		a specified time, or are empty.

		See also: fexists(1) fexists(-x)

	 ffill  fill in suppressed fields
		ffill fills in empty fields with the contents of the most recent
		non-empty corresponding field in a previous line.  In effect it is the
		inverse of suprep.

		The fields to be filled in are selected by the `-0..9' argument
		(defaults to `-0').  For example:

			ffill -03

		specifies that the zeroth and third fields are to be filled in.  All
		other fields are to be copied out directly.

		See also: ffill(1) ffill(-x) suprep double

	 filelist  maintain a file list and their collective modification time
		filelist maintains the list of files in the argument file flist,
		optionally reports gains or losses and sets flist's time stamp
		according to the status of the files it names.

		srclist is a special case link to filelist that uses the file
		called srclist._ and implies the flags -mnuv.

		See also: filelist(1) filelist(-x) srclist srclist._

	 finclude  output file resolving includes
		finclude copies its input files to its designated output, replacing any
		lines that begin with `include' (or a specified string) by a header line,
		the contents of the included file, and a trailer line.

		finclude is often used to prepare input for other processes, in
		particular strfix.

		See also: finclude(1) finclude(-x) strfix

	 finda  find and replace Ada variables
		finda searches the argument files for ADA variables that
		are named in the first field of the argument dictionary file and
		replaces those found terms by the replacement field.

		finda is almost equivalent to findc and a full description
		of the flags and processing is given in findc(1).

		termsa will produce a list of all the ADA variables found
		in the files given as input.

		See also: finda(1) finda(-x) findc(1) termsa findc findf findw

	 findc  find and replace C variables
		The four find[cfwa] programs search the argument files (defaults to
		the standard input but see -f) for terms given in the argument
		dfile (dictionary file).  findc searches for C variables; findf
		searches for fields; findw searches for words, and finda searches
		for ADA variables.  When a term is found, if the dictionary file
		specifies a replacement string (follows a tab character) the term is
		replaced by that string.

		The default (in absence of any -cru flags) action is to
		copy any lines that contain terms given in the dfile to
		the standard output.

		The find? programs are particularly useful for creating input
		to rpl.

		termsc will produce a list of all the C variables found
		in the files given as input.

		See also: findc(1) findc(-x) termsc finda findf findw rpl

	 findf  find and replace tabbed fields
		findf searches the argument files for fields that are named in the
		first field of the argument dictionary file and replaces those found
		terms by the replacement field.

		Fields are tab separated strings.

		findf is almost equivalent to findc and a full description
		of the flags and processing is given in findc(1).

		termsf will produce a list of all the fields found in the files
		given as input.

		See also: findf(1) findf(-x) termsf finda findc findw

	 findw  find and replace words
		findw searches the argument files for words that are named in the
		first field of the argument dictionary file and replaces those found
		terms by the replacement field.

		See termsc(1) for a definition of word.

		findw is almost equivalent to findc and a full description
		of the flags and processing is given in findc(1).

		termsw will produce a list of all the words found in the
		files given as input.

		See also: findw(1) findw(-x) termsw findc(1) termsc(1) finda findc findf

	 fixflist  remove non-existent files from a file list
		fixflist reads in filelist as a list of white space separated
		pathnames.  Any pathname that does not refer to an existing file is
		removed from the list.  If the -a flag is specified filelist
		itself is added to the list (subject to -a and -r special case).
		If the resulting list is empty and the -r flag is specified,
		filelist is unlinked.  Otherwise the list is sorted and written out to
		filelist.

		fixflist was created to maintain file lists within the File System
		Integrity System (see FSIC).  One of the byproducts of that
		package is a file list containing all the known temporary files (i.e.,
		a.out, core, or any file beginning with a `,').

		See also: fixflist(1) fixflist(-x) FSIC

	 flcomm  comm(1) like but columns put into files
		flcomm is a comm(1) like program that allows columns to be diverted
		to separate files and aborts in case of sequence errors or duplicated
		lines.  It was created to support the file mechanism used within the
		Q-Tree directory file system integrity check (see FSIC) previously
		called fl, hence the "fl" prefix.

		flcomm is used in FSIC package qef script to compare file lists against
		the known file lists and output the differences to specified files.

		See also: flcomm(1) flcomm(-x) comm(1) FSIC fsic(x-qsg)

	 fnd  find a command
		fnd searches the directories specified by $PATH for the argument
		file.  If it finds an executable file corresponding to the argument
		file fnd writes the full path name to the standard output.

		Flags allow the user to specify the inclusion or exclusion of
		the current directory, or the reporting of all instances in the
		path.

		See also: fnd(1) fnd(-x) pathclash which(1) $PATH(x-qvrs)

	 fndstr  find a string in a file and output offset
		fndstr searches the argument files -- defaults to the standard input
		-- for the argument string, and outputs the offset of that string if
		found.

		fndstr was provided to facilitate setting the name of the database in
		the sysnm binary.  See sysnm(1) for a description of how fndstr
		and setbytes are used to perform this.

		See also: fndstr(-x) fndstr(1) setbytes sysnm

	 form  text formatter and macro processor
		form is a general purpose macro processor that is intended to be
		used as a front end for troff(1) and other text formatters.  form is
		generally used in conjunction with a macro package, the analog of
		troff macro packages such as -ms or -man.  form has several advantages
		over straight troff: it has a more readable syntax, better macro
		definition facilities, and it can be used to make documents portable
		between different text formatters.

		It should be noted that all the Q-Tree man pages are written in
		form and that typset has a -f flag to invoke form on its
		input.

		See also: form(1) form(-x) fparens typset x-form (x-form)
			x-eml (x-eml)

	 fparens  check bracket, brace and double quote balancing in form input
		fparens processes its inputs as specified by arguments searching
		for possible problems in form input with respect to:

		* unbalanced `{'s, `[', `]', `}', and `"' characters;
		* an `@' just before the end-of-file;
		* a file that does not end with a newline;
		* a nested unescaped special character;
		* an unnested unescaped special character (suppressed if -n);
		* an `@' immediately followed a character other than one of the
		  special characters.

		Any detected anomalies are reported as rpl format lines (i.e.,
		(i.e., filename, colon, line number, colon, comment).  For example:

			cmd1/man/envset.1:000207: `{' at position 2 unclosed

		See also: fparens(1) fparens(-x) form x-form

	 ftest  test argument file attributes
		ftest tests the argument file for the attributes specified via the
		flags, outputting the appropriate diagnostic and/or taking some other
		action.

		ftest was created to eliminate the complicated and cumbersome testing
		that is sometimes required in shell or make scripts to test whether or
		not a file can be changed or exists.

		See also: ftest(1) ftest(-x) test(1) cancreat

	 g  process go files
		g is used to view and optionally remove the diagnostic output files
		of go and josh, referred to as the go-files.

		Within the qef gui, go is used to detach builds creating the files
		displayed by the build monitor.  g can be used to view those files.

		Note:	The -d flags to go and josh cause the output files to be
			created in the user's ~/.qtree/goes/<host> directory.  The
			-d flag to g causes it to look in the appropriate directory.

		See also: g(1) g(-x) go josh goes gomonitor $GODIR

	 go  detach a command
		go executes its argument command in background, usually redirecting
		the standard input and outputs, possibly sending a message when the
		argument command has completed.  go is used to detach builds within
		the qef gui, redirecting the outputs to diagnostic files that can be
		viewed using the build monitor.

		go appends messages to ~/.qtree/goes/<host>/gomsgs when a command is
		executed and when it terminates.  goes can be used to remove
		lines for completed jobs from the ~/.qtree/goes/<host>/gomsgs files.

		See also: go(1) go(-x) g goes ~/.qtree/goes/<host>
			$GODIR(x-qvrs) $GOFILE(x-qvrs)

	 goes  view or remove jobs from go message files
		go, josh, and jog append messages to ~/.qtree/goes/<host>/gomsgs
		whenever a job is dispatched and when it ends.  The following are
		examples of such records:

			pid	    command ~ host - directory yyyy/mm/dd hh:mm:ss
			pid:status  command ~ host - directory yyyy/mm/dd hh:mm:ss
			pid!	    command ~ host - directory yyyy/mm/dd hh:mm:ss
			pid:status! command ~ host - directory yyyy/mm/dd hh:mm:ss

		The `:status' fields indicate that the job has completed, the `!'
		that the job has been canceled.  For completed jobs, the command
		and directory fields may be truncated so that the entire line
		fits into 80 characters.

		goes can be used to:

		+ view job records for current, specified, or all hosts;
		+ cancel job records (i.e., insert a `!' after the pid:status field)
		  for completed jobs or jobs over a day old [*];
		+ remove job records for completed or day old jobs [*].

		[*] Can be applied to the current host's (default), a specified host's,
		    or all hosts' gomsgs files.

		Note:	jog might not be available.

		See also: goes(1) goes(-x) go josh gomonitor jog(1)
			~/.qtree/goes/<host>/gomsgs

	 gomonitor  display josh halt files as updated and other files
		gomonitor monitors the ~/.qtree/goes/<host>/gomsgs files, displaying
		job records that are appended to those files by go and josh.
		Lines for completed lines are displayed in reverse video.

		gomonitor also outputs the date and time (updated every five seconds),
		the number of messages in your mailbox, the contents of ~/.qtree/goshow
		(if non-empty) or the contents of ~/.qtree/td (see td(1)) and the
		diary entries for the next week (see diary(1)).

		gomonitor is designed to be run continuously in an xterm window,
		refreshing the date and time every five seconds and the other
		contents when they are changed.  The command:

			goes -c -h

		may be used to cancel completed commands, for all hosts, which will
		suppress their display by gomonitor.

		An alternative to gomonitor is provided by the Build-Monitor window
		of the qefgui.  It provides facilities for viewing the go files
		as they are created, removing selected go-files, halting or rerunning
		jobs, and many more facilities.

		Note:	td(1) and diary(1) may not be part of your system.

		See also: gomonitor(1) gomonitor(-x) josh g goes Build-Monitor(x-qefgui)

	 gotstr  output names of files that contain argument string
		gotstr outputs the list of files named in filelist arguments (defaults
		to the standard input) that contain the argument string, and it does so
		very quickly by using a Boyer/Moore algorithm and reading 32K at a time.

		Frequently gotstr is used to prepare an argument list for grep(1) as in:

			grep pattern `gotstr string filelist`

		or better:

			gotstr string filelist | qrep -F pattern

		See also: gotstr(1) gotstr(-x) qrep bm(1)

	 grpsort  sort groups of lines specified by ranges
		grpsort reads its input files, searching for lines that match the
		specified argument regular expression.  The matched line and the lines
		that follow up to (but not including) the next matched line constitute
		a group.  All lines are copied to a temporary file and the matched
		string and the offset to its group are saved.  Once all the input has
		been read, the matched strings are sorted.  Then the groups are read
		from the saved input in the sorted order and output.

		Note:	If the pattern contains a sub-pattern -- specified by `\(...\)'
			the string matched by the sub-pattern is used as the sort key.

		As an example of its uses, grpsort is used to sort x_db entries, each
		of which begins with `%{' optionally followed by a `-' and white
		space.  Thus to sort the entries of an x_db database by the first
		key of a line one uses:

			grpsort '^%{<-|>[ ]*\(.*\)'

		See also: grpsort(1) grpsort(-x)

	 hhmmss  output a banner of the time
		hhmmss clears the screen and outputs a banner of the time as in:
		
		     #     #######   #   #        #######   #     ###     #####
		    ##     #    #   ###  #    #   #        ###   #   #   #     #
		   # #         #     #   #    #   #         #   #     #  #     #
		     #        #          #    #   ######        #     #   ######
		     #       #       #   #######        #   #   #     #        #
		     #       #      ###       #   #     #  ###   #   #   #     #
		   #####     #       #        #    #####    #     ###     #####
		
		Note that this representation of the time is legible when using the
		``tiny'' or ``unreadable'' xterm fonts.

		An alternative representation is provided that uses highlighting
		which is somewhat more attractive.

		By default, the display is refreshed every ten seconds on the ten
		second time.  An interrupt (usually Ctrl-C) will cause the time to
		be refreshed every second and a subsequent interrupt will revert to
		refreshing on the ten second mark.

		To terminate the clock use two interrupts within a second.

		An option (-S) is provided which shows a count down or elapsed
		time, which when combined with the highlighting representation
		is very useful for showing students the time left for an exam.

		See also: hhmmss(1) hhmmss(-x) xclock(1)

	 hoff  hell of a lot faster than nroff
		hoff is a much cut down (might I say absurdly cut down) version of
		nroff(1) to be used to format simple documents or quickly left
		justify and fill lines.

		For example, hoff was used to justify and fill these lines
		just by piping them through hoff within the editor (qed)
		using:

			?much cut?,. | hoff

		A list of the supported commands can be found in hoff(-x).

		See also: hoff(1) hoff(-x)

	 howto  output selected howto information
		When howto is invoked with an argument X, it searches for a file called
		Howto.dir/X in the directories named by $PATH.  If such a file is found
		and it begins with the sequence `#HT' followed by a tab, the file
		is copied to the standard output, after replacing certain `%'
		sequences with run-time values (e.g., the date or user's name) or
		interpretations.

		howto is used to describe various procedures and/or standards.

		If howto is invoked without arguments, it outputs a list of all the
		howto files available.

		howto is a link to bp.

		There are a number of howto files provided by default:

			dirsetup	How to edit a dirsetup database
			help		How to help someone use a computer
			howto		How to create a new howto file
			swhygiene	Stenning's Project Hygiene Principles and Suggestions

		The author finds it a convenient mechanism for storing and accessing
		miscellaneous information.

		See also: howto(1) howto(-x) bp

	 incls  dynamic dependency tracker
		incls takes as input a list of files and outputs the implied
		dependencies.  Its primary purpose is to maintain the incls._
		database and to produce the dependency list used within the qef
		scripts.

		incls uses finite state automatas stored in files produced by
		mkdeps to the argument files.

		The qvrs variable SrcProdMap[class] may be used to extend the
		list of affixes and their dependencies as generated by the -M
		and -m flags.

		incls will consult and update a universal cache of dependencies
		in a DBM database named by @InclsDbm.  Using such a database
		saves rescanning commonly used headers such as stdio.h.
		See incls.dir and InclsDbm.

		See also: incls(1) incls(-x) mkdeps incls._ dmpdeps depsmap
			SrcProdMap incls.dir InclsDbm InclsDbmUpdate

	 instal  meticulously install a file and audit it
		instal [sic] is used to install files in remote directories.  instal
		accepts flags from the qvrs variables @_F_instal and @_F_instal[root] as
		well as on the command line.  It maintains an audit trail in the path
		named by qvrs variable @InstLog.  instal works hard to check that
		everything happened correctly.

		Of particular importance is the -I flag which causes instal to not
		fail if it cannot set the specified mode, owner and/or group.  In such
		an instance, instal outputs a noisy warning message and records the
		failure in file named by appending `.fix' to @InstLog (after removing
		`.log' if it exists).  The failure is recorded in the format read by
		tchown which can be used by a privileged user at the end of the
		build.  This feature means that one does not need to be the root user
		to build installations!!

		So why's instal misspelt?  See faq8.

		See also: instal(1) instal(-x) _F_instal(x-qvrs) InstLog(x-qvrs) tchown

	 instdir  install a directory
		instdir is a link to instal that creates directories.

		See also: instdir(1) instdir(-x) instal instdir(x-qsg)

	 instfls  install files, but only if necessary, according to script
		instfls reads its input script which contains a number of
		source/destination path name pairs.  It installs the source files into
		the destination files, but only after checking to ensure that the
		installation will result in a significant change.  A history file is
		maintained to suppress file comparisons if the files have not changed
		since the last time instfls was run.

		instfls can also take a list of files and the names of the source and
		destination directories.

		See also: instfls(1) instfls(-x) instfls(x-qsg) instal
			if_install._ih if_install._il

	 jlines  join up selected lines
		jlines copies the named file(s) (defaults to the standard input) to
		the standard output, replacing selected newlines (i.e., joining some
		lines) by specified string.

		Normally, newlines escaped by a concatenation character (default `\')
		are removed (together with the escape concatenation character).  By
		default, the concatenation character is assumed to precede the newline
		but one can choose to have the escape character appear after the
		newline to be removed (i.e., at the beginning of the next line).

		See also: jlines(1) jlines(-x)

	 josh  a job shell
		josh is a command interpreter that manages jobs selected by name
		from the specified josh file -- defaults to ~/.qtree/josh.

		A josh file consists of lines of the following form:

			# comments		say no more
			X=value			assign a value to variable X
			group ~ pats ...		specifies that `group' implies jobs
						matched by specified patterns.
			labels...: commands	the jobs to be done; commands may
						be continued over multiple lines
						and incorporate variable values
						and command line arguments.

		josh selects jobs to be done by those labels or groups matched by
		command line specified patterns.  The associated commands are then
		interpreted using the shell.  Flags are provided to detach the job
		redirecting the output as is done by go, in which case josh
		maintains a josh halt file that records progress and can be used
		to halt a josh job.

		An extremely important task performed by josh is to facilitate remote
		executions of qef jobs as described in Remote-Qefs.

		See also: josh(1) josh(-x) gomonitor go g Remote-Qefs
			$GODIR(x-qvrs) $GOFILE(x-qvrs)

	 kdbm  extract from or add to DBM database
		kdbm is a tool used to create, update and query a DBM database.
		Basically a kdbm database uses ASCII keys with single or multiple
		text line data elements.

		See also: kdbm(1) kdbm(-x) ldbm sdba

	 l  list files in columns
		l is yet another ls(1) type program that lists entries in the
		specified directories.  It is provided as part of the Q-Tree
		to ensure a consistent interface and provide additional
		capabilities not normally available using ls.

		lc is a link to l that implies the -a and -l flags -- list all files
		(-a) by file-type (-l).

		Note:	Some man(1) commands cannot retrieve l(1) due to their
			interpretation of `l' as being a section number.  In
			such a case see lc(1).

		See also: l(1) l(-x) lc lc(1)

	 lash  long argument list shell interface
		lash runs its argument command repetitively for the specified
		arguments -- possibly read from the standard input.  The command
		should contain % character sequences to specify the positions and
		forms of the arguments.  Supported forms include selecting the
		argument's directory, basename, root, etc.

		A command may also use multiple arguments.

		lash is similar to the BSD tool apply.

		See also: lash(1) lash(-x)

	 lc  list files by type in columns
		lc is a link to l that lists the files in the argument directory
		by type (e.g., directories, devices, etc).  It also lists all
		files whereas l suppresses files whose names begin with a `.'.

		See also: lc(1) lc(-x) l

	 lcmp  compare two files
		lcmp compares the two argument files byte by byte and reports any
		differences as the octal address (see -d flag) of the difference and
		the symbolic representation of the characters in each file separated
		by tabs, as in:

			000117  \t      ` '
			000120  007     x
			000340  EOF     \n

		In most respects, lcmp is equivalent to cmp(1) with the -l flag.
		The differences are the use of the symbolic representation of the
		characters, use of octal addresses, and treatment of the EOF.

		See also: lcmp(1) lcmp(-x) cmp(1) fcmp

	 ldbm  extract from or add to DBM line database
		ldbm is used to create, update and query an ldbm database.  which
		is a DBM database (i.e., X.{dir,pag} pair) in which a key's data
		item (as stored in the X.pag file) is a list of seek offsets into
		third file X.data.  The offsets point to newline terminated lines
		of text for the key.

		See also: ldbm(1) ldbm(-x) kdbm sdba

	 ledmp  display current lefile values
		ledmp outputs the tables size, termcap strings and key mappings
		contained in the argument leditor control file (default $LEFILE,
		$LEDIR/${TERM} or <qtree-root>/lib/ledir/${TERM}).  Flags may
		be used to select one or more of the output tables.

		See keys(x-lledit) for a list of the leditor keys.

		See also: ledmp(1) ledmp(-x) leset (x-lledit) leditor $LEFILE

	 leset  set up line editing keyfile
		leset creates and writes to object (defaults to the standard
		output) the setup file needed for the leditor control file used in
		qed and other tools.  Normally this file is stored as
		<qtree-root>/lib/ledir/${TERM}. However, the user may specify an
		explicit lefile by setting the $LEFILE shell environment variable or
		may specify a directory to be searched before looking in the standard
		position by setting $LEDIR.

		The input file syntax is described briefly in leset(-x) and fully
		in leset(1).

		The special keys symbols and their semantics are listed by the -k flag.

		See also: leset(1) leset(-x) leditor ledmp

	 liborder  process nm of a library to produce dependency graph
		liborder reads a snm output for a library and produces a dependency
		graph of the library's modules.  This output is usually input to
		topolsrt (or tsort(1)) to produce a topologically sorted list of
		the library's modules.

		liborder used to be required on some old platforms to create the
		ordered list of modules, however, this has been rendered unnecessary
		by ranlib(1) or ar(1) features.

		See also: liborder(1) liborder(-x) snm topolsrt

	 libs  output information on libraries used by the named files
		libs processes a list of symbolic library names given via arguments,
		or the libraries specified for an argument file via the LIBS[]
		variable or as embedded in the files themselves as in:

			/* LIBS: -ldtree

		By default, libs outputs the library names or symbols that will be
		used when linking the named file or library.  Flags may be specified
		to show the raw library list (-r), the list after LibMap expansion
		is done (-m), the expanded list after the library search is done (-e)
		the list of symbols to be used when linking (-c), and list all
		libraries that match a specified symbol (-A).

		Try:

			libs -aA -lc

		Note:	If a libs argument begins with [name], as in:

				libs [alternative]/.../realfilename.c

			then alternative is used to match LibStatic[] patterns, instead
			of realfilename.

		Note:	The qvrs -l flag outputs a list of all the variables used
			in library searches and their current settings.

		See also: libs(1) libs(-x) *lib-macros(x-qefpp) *lib-vars(x-qvrs)

		Apropos: ? -Q <Lib|archive|libs>

	 lines  print first N and last M lines
		lines prints the first head (default 5) and the last tail
		(default 0) lines of each argument file (defaults to the standard
		input) or the files named by the files or the standard input if the
		-f flag is specified.  lines also supports a -r flag which
		causes lines to output lines in the rpl format, for example:

			file:000123:contents of line # 123 in file

		See also: lines(1) lines(-x) rpl

	 linked  list files with multiple links
		linked checks the argument files (defaults to files named in the
		standard input) or the files named by the argument files (if -f)
		for files that exist and have multiple links.  If there are 1 or less
		links nothing is output, otherwise the name of the file is output.

		A flag (-s) is provided that output those files that are symbolic
		links.

		See also: linked(1) linked(-x)

	 lls  ls for input files with selected fields output
		lls is yet another variant of ls(1), with the difference that
		the files to be listed may be named by the standard input or the
		argument files and the file attribute fields displayed are
		selectable by a command line option (see -o).

		The list of selectable fields is output by lls(-x) and given in lls(1).

		See also: lls(1) lls(-x) rls

	 lninsert  replace characters in master by lines from source
		lninsert reads the master file and searches it for the replacement
		character (defaults to '%').  Each replacement character is replaced,
		in the output stream, by characters from the source file, up to the
		next newline not preceded by a backslash.  The newline is included in
		the output unless the -n option is specified.  The resulting merged
		stream is written to the standard output.  Either one of the master or
		source files may be assigned to the standard input by using a `-'
		instead of a file name.

		lninsert is yet another useful tool for merging lists of fields into
		a master form, possibly repeating the master, to create form letters
		or database entries.

		F.Y.I.:	lninsert is ancient, dating back to fourth edition UNIX.

		See also: lninsert(1) lninsert(-x)

	 lntree  create tree of symbolic links to input file list
		lntree reads a list of pathnames from the argument file (defaults to
		the standard input) and creates a ``shadow'' tree in the current
		directory that consists of symbolic links to the input pathnames
		relative to the argument fromroot.  Hard links are used if symbolic
		links are not supported by the host system.  Directories are created
		as required.

		Pathnames in the argument files or the standard input are separated by
		white-space or newlines.  Strings following a `#' at the beginning of
		a line or after a space or tab are ignored.

		If the n flag is specified, lntree does nothing other than to report
		what it would do.

		See also: lntree(1) lntree(-x) ln(1) link(2) symlink(2)

	 man3db  apply trg script to selected items from man3 TIPs database
		man3db is a special purpose TIPs trg program that will apply the
		built-in trg program format or the trg source file trg as specified by
		the -b or -t arguments to the items in the specified files or the
		``*.d'' files in the argument dir (default ``*.d'').  If a -q flag is
		given, only those items that match the argument Tips query are
		processed.

		man3db is used to produce the x_db libraries such as x-ldtree.

		man3db entries describing the routines of the library are embedded
		in the actual source.  man3db extracts these entries and processes
		them with a built in man3db format that produces x_db formatted
		information (possible being processed through form and grpsort).

		See also: man3db(1) man3db(-x) man3db(x-qsg)

	 manprep  prepare manual sections for qef info tool
		manprep is used to transform output of man(1) into the form required
		for presentation by the qef graphical user interface.  The output
		consists of Tcl/Tk expressions specifying bold text, section headers,
		and references to other manual sections.

		See also: manprep(1) manprep(-x)

	 mimk  issue updating commands according to a dependency script
		Yet another make(1), but built specifically to be a suitable back-end
		for qef.  mimk duplicates most of the important functionality of make,
		but does not support variables or suffix rules, as such things are done
		in other qef processes.  mimk will run processes in parallel and will
		rerun constructions if the dependency list or the constructions itself
		has been changed since its last execution.

		See also: mimk(1) mimk(-x) qhy qmkhist._

	 mkalltraits  run mktraits on remote hosts
		Without any flags or host arguments, mkalltraits runs:

			qremote -h <host> mktraits -u

		for all hosts <host> for which the variable <host>.qtree exists in the
		qdsrv database.  The mktraits will rebuild the <Q>/data/traits/<host>.tab.

		This is usually necessary after <Q>/lib/traits.vrs or <Q>/data/traits.ext
		files are changed and the traits binary files stored in traits/<host>.tab
		files need to be rebuilt.

		The -r flag specifies that rsh(1) is to be used instead of qremote as
		might be required when qremote cannot be run due to a missing traits
		file.

		See also: mkalltraits(1) mkalltraits(-x) traits qremote qdsrv

	 mkddt  create ddt declaration
		mkddt transforms its argument input files into a C header or source
		file (if -c) containing appropriate initializations for Ddt_t
		structures used to control the Dynamic debugging trace (ddt) package.

		mkddt is used to build qef itself and a number of other Q-Tree
		packages.  It is not intended for general use at this time.  As such
		it might not be available.

		See also: mkddt(1) mkddt(-x)

	 mkdeps  compile deps scanner file
		mkdeps compiles a description and control variables of the scanner
		used to process files to extract embedded dependencies such as the
		`#include' statements of C.

		The resulting object file is used by various programs (e.g., incls)
		to extract embedded dependencies from a source file.  Such files are
		usually stored in <qtree-root>/lib/deps.

		dmpdeps may be used to examine and/or test a mkdeps object or an
		installed version.

		depsmap is used to create a file that maps from file suffixes to
		mkdeps object files.

		Warning: The mkdeps language is obtuse and baroque.  It is not
			intended for the casual user.  If you need a new language
			supported, write to support@qef.com and it will be created.

		See also: mkdeps(1) mkdeps(-x) incls dmpdeps depsmap mkdeps(x-qsg)

	 mkerrs  process error databases to produce other source
		mkerrs processes a library's error database to create required header
		files. The user provides a TIPs error database.

		mkerrs is used to convert entries in these files to the two C language
		header files required to use the error handling package.

		mkerrs is used to build the Q-Tree product itself so is provided
		as part of that product.

		See also: mkerrs(1) mkerrs(-x) mkerrs(x-qsg) TIPs

	 mkopts  create options header file
		mkopts creates a C language header file of defines for options.  It is
		used to create header files based on qvrs option settings.

		A qsg library script (mkopts(x-qsg) exists to create header files
		using mkopts.

		See also: mkopts(1) mkopts(-x) mkopts(x-qsg)

	 mkqtree  set up new qef tree
		mkqtree creates a new qef shadow tree for the current directory.
		Given the command:

			mkqtree -t@TreeType directory subtrees ...

		mkqtree performs the following:

			mkdir directory		# if directory does not exist
			cd directory
			rootvrs -tTreeType original-directory # if no root.vrs
			confvrs -c		# if conf.vrs does not exist
			treedirs subtrees ...	# if subtrees not .

		The above creates the new directory, creates the root.vrs file linking
		the new directory to the original, copies confvrs/confdefl.vrs to
		conf.vrs and populates the tree with the requested sub-directories.

		See also: mkqtree(1) mkqtree(-x) rootvrs confvrs treedirs confdefl.vrs

	 mkquete  produce manual section index
		mkquete processes manual sections to extract the short description
		in the NAME section and to build output records in the following form:

			section name <tab> description

		Flags or the traits variables ManSections and ManZipSuffixes name the
		manual sections to be processed and the suffixes for compressed
		files respectively.

		mkquete is run to produce <qtree-root>/data/quete/*.db which is read by
		quete to create a manual section topic list within the help information
		window in qefgui.  See QueteDbs(x-qefgui).

		See also: mkquete(1) mkquete(-x) man(1) traits data/quete quete.db-maint

	 mksolib  create shared library externs list
		mksolib is used to convert a list of variables and their types into
		a C module which can then be linked with a library to create a
		shared object (i.e., so) library.

		Basically to create a shared library, a mksolib input file is created
		that lists at least one variable from every required module in the
		archive.  When such a file is processed by mksolib, and then compiled
		and linked with the standard object library (with the appropriate
		flags), a shared library containing the defining modules for each
		of the listed variables is created.

		A qsg library script (mksolib(x-qsg)) exists to facilitate mksolib's use.

		See also: mksolib(1) mksolib(-x) mksolib(x-qsg)

	 mktraits  compile traits files
		mktraits creates the traits database <Q>/data/traits/<host>.tab.
		The traits database is a set of variable/value pairs used to store
		system, host, and site settings such as capabilities, pathnames, and
		special values such as QDSRV_HOST.

		mktraits compiles the traits source files traits.vrs and traits.ext.

		The language used in these files is identical to that of qvrs, except
		that the trait(x-qvrs) function is not supported.

		Note:	Whenever mktraits -Ru is run, any traits/<host>.tab file
			that is older than either of the source files is removed.
			Running traits or any query of the traits database via the
			libdtree.a A.P.I. will recreate the file if necessary.

		See also: mktraits(1) mktraits(-x) traits trait(x-qvrs) trait(x-qsg)
			traits-vars traits/<host>.tab

	 mkvernum  create or change version string
		mkvernum extracts the current module version number from the qvrs
		variable Revision[module] or Revision and generates a version string
		for embedding in the code or library.  Many of the qsg scripts
		support a -v flag that will automatically create, compile and add
		the version string to a program or library.

		One of the important mkvernum features is its ability to embed the
		value of a counter that is incremented on each use in the output
		string.  These counters are retrieved by communicating to qdsrv
		which maintains <Q>/data/mkvernum.db.

		Note:	vcc is a link to mkvernum used to create and compile a
			C version file.

		See also: mkvernum(1) mkvernum(-x) vcc qdsrv vernumcomp verlib/
			<Q>/data/mkvernum.db Revision(x-qvrs) _F_mkvernum_cc(x-qvrs)
			ReportMkvernum MkvernumFormat MkvernumPath RevisionString

	 mnfadd  add a new manifest to manifest database
		mnfadd is part of the manifest package -- see mnfdb.  mnfadd adds a
		new input manifest to a manifest database and outputs the result.

		See also: mnfadd(1) mnfadd(-x) mnfdb manifest(x-qmisc)

	 mnfchk  check manifest database for syntax and consistency
		mnfchk is part of the manifest package -- see mnfdb.

		mnfchk reads the argument manifest database -- defaults to the
		standard input -- outputting any syntax errors in the manifest
		database to an argument file -- defaults to the standard output.  If
		the -S flag is specified, for all files/version tuples in the selected
		releases (defaults to all), mnfchk finds the associated s-file and
		checks that the named version actually exists.

		See mnfchk(1) for a list and explanation of the errors that can
		be output.

		Note:	The -S check works with SCCS files only.  To check a manifest
			for some other system, use mnfput -m to retrieve the files
			and associated versions and input that information to a mechanism
			that checks the validity of the file/version tuples.

		See also: mnfchk(1) mnfchk(-x) mnfdb manifest(x-qmisc)

	 mnfcmp  compare two manifests
		mnfcmp is part of the manifest package -- see mnfdb.

		mnfcmp compares two manifests reporting the differences in three tab
		separated fields, giving the file name, the file's version numbers in
		the first and the second manifests.  If a file is not listed in either
		one or the other manifests the associated version field is output as a
		single caret (`^').

		See also: mnfcmp(1) mnfcmp(-x) mnfdb manifest(x-qmisc)

	 mnfdb  output manifest database release information
		mnfdb outputs the release information for the releases selected by
		the -r flags (defaults to -r \*) in the named manifest database.

		mnfdb is part of the manifest package which consists of the following
		tools:

		  mnfadd  add a new manifest to manifest database
		  mnfchk  check manifest database for syntax and consistency
		  mnfcmp  compare two manifests
		  mnfdb  output manifest database release information
		  mnfdel  delete releases from manifest database
		  mnfput  output a manifest or manifest database

		See mandb(1) for descriptions of manifests, manifest databases,
		releases, and the care and feeding of manifest databases.

		See also: mnfdb(1) mnfdb(-x) manifest(x-qmisc)

	 mnfdel  delete releases from manifest database
		mnfdel is part of the manifest package -- see mnfdb.

		mnfdel is used to remove a named release or releases from a manifest
		database.  The associated release declarations are removed as are all
		bindings of file/version tuples to those releases.  The resulting
		manifest data is output to a named file or the standard output.

		See also: mnfdel(1) mnfdel(-x) mnfdb manifest(x-qmisc)

	 mnfput  output a manifest or manifest database
		mnfput is part of the manifest package -- see mnfdb.

		mnfput reads the selected manifest database and outputs the named
		releases.  The -m flag outputs a resolved manifest.  If multiple
		releases are selected and those releases specify differing versions
		for a specific file, the version specified by the youngest selected
		release is output.

		See also: mnfput(1) mnfput(-x) mnfdb manifest(x-qmisc)

	 necho  echo with escape interpretation
		necho just echos its arguments, much the same as echo(1).
		However, necho provides special character interpretation in its
		arguments to facilitate specification of non-printable characters,
		such as "\r", "^M", or "\15" for carriage return.

		necho also provides output redirection via arguments, which may
		be necessary to ensure correct interpretation or alternatively
		eliminate the need to invoke a shell.

		See also: necho(1) necho(-x) echo(1)

	 numb  produce numbered lines
		numb reads lines from the argument files (defaults to the standard
		input) and outputs the line with a line number.

		An option (-f) exists to allow the specification of the output format.

		See also: numb(1) numb(-x)

	 olex  lexical analyser builder
		olex is the original lex(1) provided to circumvent the limitations
		of flex(1).  It is required to boot the Q-Tree as the lex sources
		all use feature in control the I/O that cannot be emulated within flex.

		Note:	DO NOT USE!!
		See also: olex(1) olex(-x) qlex(1) _T_lex lex(1)

	 p4files  list perforce files for the current root
		p4files is used to produce a list of the files in the perforce files
		in the appropriate branch.

		Basically p4files builds a p4 command to list the files in the depot.
		The most basic command is "p4 -sync -n".a

		The command's output is read by p4files to extract the file name, the
		type, and the revision number.  The output will consist of the
		filename, relative to the current directory, the optional affix, the
		type in parentheses, and the revision number (if the -M flag was
		specified).

		This input will typically be sent to sfsic to compare the perforce
		depot's files against the FSIC file lists.

		See also: p4files(1) p4files(-x) p4mnf perforce(1) p4(1) sfsic sfsic.cf

	 p4mnf  list p4 files for the current root
		p4mnf is used to produce a file manifest in the perforce(1) files
		in the appropriate branch.

		Basically p4mnf builds a p4(1) command to list the files in the
		depot. The most basic command is "p4 files".

		The command is modified to add additional flags -- e.g., -x-, d
		depot.

		The constructed command is executed, possibly with the argument files
		or files specified by those files (if -F flag specified) input to
		the command as the standard input.

		The command's output is read by p4mnf to extract the file name and
		the revision number which are output with a separating tab.

		This input will typically be with the mnfdb package to maintain a
		release database.

		Note:	m4mnf is very similar to p4files.

		See also: p4mnf(1) p4mnf(-x) p4files perforce(1) p4(1) mnfdb

	 pa  output, list, or delete cut files
		pa and its companion tool ct paste and cut files.  When ct is
		invoked it copies its input into a file in the user's $CTDIR
		(default ~/.qtree/ctdir) directory.  The name of the new file is
		`,' followed by two decimal digits.

		pa can be used to list, examine, retrieve and/or remove cut
		files by relative age or explicit index.

		The default command is to cat the most recently modified file
		in the $CTDIR directory.

		See also: pa(1) pa(-x) ct $CTDIR ~/.qtree/ctdir

	 parmsdb  output parms database in variety of formats
		parmsdb processes the specified parms database -- defaults to
		<qtree-root>lib/parms -- for items that match the specified query
		(default all) and outputs those items in the selected format --
		defaults to ``default''.

		The parms database describes the parameters used to configure the
		Q-Tree for the system.  The parameter files are parmsdb dictionaries
		normally stored in the magic/parms directory of the Q-Tree source.
		Typically a parameter assigns a string value that will be used to
		configure header and data files during the boot strap.

		Unfortunately, the database tends to slip out-of-date.

		See also: parmsdb(1) parmsdb(-x)

	 pathclash  produce list of duplicated executables in path
		pathclash outputs the file names that occur in more than one of the
		directories named by $PATH -- in other words, the path name clashes.

		It is provided to facilitate quick determination of whether or not any
		of the qef tools clash with existing tools in the user's $PATH.

		See also: pathclash(1) pathclash(-x)

	 pathto  map argument file to special directory
		pathto maps its argument files by replacing symbolic prefixes
		to real pathnames.  The symbolic names are listed by the -l flag.

		pathto is used in shell scripts to facilitate specification of
		Q-Tree (and other) files by applying the appropriate substitution
		and search mechanisms.

		pathto may be used to determine the default <qtree-root> using:

			pathto -d qt

		Note:	Additional symbolic mappings can be specified in the
			roots.map files.

		See also: pathto(1) pathto(-x) QTREE <qtree-root> roots.map

	 pdirs  directory stack manipulation for shells without pushd
		pdirs is provided for use on systems that lack that very useful function
		pushd.  pdirs should not be used directly as its purpose is to
		deliver an argument for a chdir and to maintain a list of directories
		which must be done using built-in shell functions.  To use pdirs,
		one should use:

			% eval `qfunc pdirs`

		which defines the following functions:

			pd () { eval `pdirs -e $* ++ $_dirs` ; }
			pushd () { eval `pdirs -e $* ++ $_dirs` ; }
			popd () { eval `pdirs -ep $* ++ $_dirs` ; }
			dirs () { echo `pwd` $_dirs ; }

		The resulting functions pushd, popd, and dirs provide much the
		same functionality as their csh name-sakes.

		See also: pdirs(1) pdirs(-x) sh(1)

	 ph  output phone numbers for selected contax database entries
		ph is a link to contax.  The only difference is that invoking
		contax using ph automatically assumes the -b ph option.  That
		option selects the ``ph'' output format which outputs the phone
		numbers for the selected entries.  For example, the command:

			% ph tilbrook

		would yield:

			David Tilbrook: (+1 416) 925-8168 (office)
					(+1 416) ...-.... (mobile)
			Frank Tilbrook: (+1 416) ...

		See also: ph(1) ph(-x) contax

	 putifdif  copy input to output file if different
		putifdif compares its standard input to contents of its argument file,
		copying the input to the argument file if they differ.

		putifdif is used to process configured header files, changing the
		installed copy only if its contents would change.

		See also: putifdif(1) putifdif(-x) cpifdif

	 qconfset  add variable setting to the conf.vrs file
		qconfset is provided to insert or replace a variable setting or an
		option at the beginning of the current tree's conf.vrs file, if there
		is one.  The conf.vrs is the qvrs file used to specify the user's
		options and controls.  It is typically initialized using confvrs which
		copies the default configuration file confvrs/confdefl.vrs.

		See also: qconfset(1) qconfset(-x)

	 qd  shell alias/function to chdir using selected qdsrv database entry
		To facilitate changing directories within the shell one sets the following
		alias or function:

			alias qd 'set qdtmp=`qds -d \!*` && cd $qdtmp'	# in csh

			qd () {
				qdtmp=$(qds -d $*) && cd $qdtmp
			} # in sh, ksh or bash

		The above are also output by the qds -X flag and qfunc qd.  To define
		qd one uses:

			eval `qfunc -c qd`	# in csh
			eval `qfunc qd`		# otherwise

		Once set, one can use qd to chdir to trees or sub-directories within
		a tree using queries, absolute indices, or qds flags such as -n
		or -i.

		Note that an argument to qd may be used to specify the sub-directory
		of the target tree.  If the target tree is the same project as the current
		tree, the qd will chdir to the same sub-directory of the target tree.
		To specify the root of the tree, on should begin the argument with a
		slash as in:

			qd <qds flags> /sub-dir

		See also: qds qfunc

	 qdchk  check host's qdsrv database entries
		qdchk retrieves all the paths for the current host from the qdsrv
		database -- see qdsrv(1).  For each retrieved path entry, qdchk
		checks the fields and directories for validity reporting any
		discrepancies.

		The error and warning messages produced by qdchk are explained in
		individual items of x-qmisc.  See *qdchk(x-qmisc).

		See also: qdchk(1) qdchk(-x) qdsrv qdsrv-record *qdchk(x-qmisc)

	 qdid  assign qdsrv ident and/or bind to path
		qdid provides support for retrieving an unused qdsrv identifier and/or
		binding a qdsrv identifier to a qdsrv database entry.
		Once an identifier is bound to a path, qds -i may be used to retrieve
		that path.  Thus a user may identify a path that represents the current
		set of working directories.

		The environment variable $QDSRV_ID may be used to contain the identifier.
		If QDSRV_ID is not set the lowest identifier is assigned to the user.

		Note: qds also has an option to do the path binding.

		See also: qdid(1) qdid(-x) qdsrv qds $QDSRV_ID

	 qdmgt  general qdsrv management interface
		qdmgt provides a generalized message interface to qdsrv.  It sends
		argument message (possible specified by a flag) to the server and then
		just writes the returned messages to the standard error output (if the
		returned message begins with a `!') or to the standard output.

		qdmgt was developed initially to test the server prior to the
		existence of the specialized tools.  As such all the qdsrv services
		may be invoked via qdmgt and some are available only by using it.

		The list of messages supported by qdsrv is produced by the command:

			qdsrv -X

		Note:	To edit the database one must:

			qdmgt -v	# check that server running and get db name
			qdmgt -f	# freeze the database
			edit <dbfile>
			qdmgt -r	# reread the database and unfreeze it

		See also: qdmgt(1) qdmgt(-x) qdsrv qds qdchk

	 qds  select and print entries from qdsrv database
		qds retrieves paths from the qdsrv database.  Flags can specify attributes
		(e.g., project, release, host) of the paths to be retrieved.

		The primary purpose of qds is to provide the argument to a chdir command.
		The -d flag specifies that a single path must be selected.  If a single
		path is matched, the matching paths are output.

		qds is used in the qd function or alias to facilitate chdiring
		using queries or path indices.

		See also: qds(1) qds(-x) qd qdsrv qdmgt qfunc

	 qdsrv  qef project database server
		The qdsrv database, usually contained in <qtree-root>/data/qdsrv.db
		contains information about qef administered trees.  qdsrv is a
		server program that provides facilities:

		* to change, create, or delete path database entries
		* to reserve, set and retrieve qdsrv identifiers used to anchor a
		  user's session to a particular path
		* to freeze (prohibit changes) or reload the database
		* to retrieve the version and process information of the running
		  server
		* to halt the server
		* to retrieve the time on the server's host

		qdsrv should be run on a host on the local network.  The host on
		which it runs and its port number are named by the traits QDSRV_HOST
		and QDSRV_PORT -- see traits(1).

		Note:	The uid of the qdsrv process must be the owner of the
			database.  Thus the qdsrv executable should be setuid
			to the owner of the database.

		See also: qdsrv(1) qdsrv(-x) qdsrv.db qdsrv.log mkvernum.db qds
			qdmgt qdid qdchk traits qhost QDSRV_HOST QDSRV_PORT
			qdsrv-setup rc.d/qdsrv(x-qefeg)

		Apropos:	? qdsrv

	 qdupd  add path to qdsrv database
		qdupd is used to add or change a path and its corresponding parameters
		to the qdsrv database (usually stored in <qtree-root>/data/qdsrv.db).

		See qdsrv(1) for a description of the fields of the database and their
		use.

		Note:	rootvrs invokes qdupd to add or correct paths when a new
			root.vrs file is created or changed.

		See also: qdupd(1) qdupd(-x) qdsrv rootvrs qdsrv.db

	 qed  somewhere between a line editor and a command interpreter
		qed is a multiple-file programmable text editor and a programming
		language based on ed(1), intended for use primarily by programmers.
		For the average user, qed's power will likely be unnecessary, even
		troublesome, and its use is discouraged.  For a "knowledgeable" user
		who is willing to learn how to use it properly, however, qed is a
		powerful tool, both when used as an editor or as a (rather
		idiosyncratic and low-level) programming language.

		However, it is the only editor the author uses.

		There is an ancient (1980) tutorial on qed use in the <Q>/doc
		written by Rob Pike and David Tilbrook.

		Some interesting features:

		- use of leditor to provide cursor editing and key mapping
		- rich set of functions -- see (x-zr)

		See also: qed(1) qed(-x) qedbufs x-qed x-zr

	 qedbufs  output qed save file structures
		qedbufs examines the contents of a qed ``save'' file, as created
		by the qed S (for ``save'') command.

		The S command writes the contents of all buffers into a file called
		X._qa where X is supplied as part of the S command (default
		``q''). It also dumps all the buffer controls (i.e., the zero, dot &
		dollar) and the register contents into a file called X._qb.

		qedbufs outputs some or all of the contents of the X._qb file,
		where X is the argument prefix (default ``q'').

		See also: qedbufs(1) qedbufs(-x) qed R(x-qed) S(x-qed)

	 qef  the driver
		qef is the user interface and driver for the system.  Consists of three
		major phases:

			1) Configuration
			2) Script preparation
			3) Script Interpretation

		1) The first phase consists of initialization and various validity
		   checks (see ForbidQef), output of the header line, etc., but the
		   most important aspect is to run qvrs to compile the qvrs-files
		   into a database that is saved in /tmp/qv_*.tmp for consultation
		   by qef and other tools.

		2) Every directory in which qef is to be run must have an associated
		   qeffile (or a qeffile2), which is found by searching the @SrcPath
		   directories or as named by QefFile[@RealBranch].  This file must
		   contain a Begin line. This line plus other qvrs settings are used to
		   determine how the back-end input script is to be prepared. Usually this
		   is one of the following:

		      *	run qefdirs to convert qeffile to a script which is processed
			by qefpp to produce a mimk(1) file that handles constructions
			across multiple directories; or
		      *	run sls to produce a list (srclist._) of the source files
			for the current directory and then invoke qsg to transform that
			list and the contents of the qeffile into qefpp input which
			will produce input to the back-end.

		   Other variations are possible, but the above two represent over 95%
		   of qeffiles.

		3) The back-end, as named by _BackEnd_, is invoked to interpret the script
		   prepared or selected by the second stage.  In most instances the
		   backend will be one of mimk, qsh, or make.  Once the back-end
		   has completed, qef performs a number of clean-ups (e.g., removing
		   its temporary files), outputs the trailer line and exits.

		The manual section qef(1) gives a more complete description of the
		processing.  Also see the few hundred other sections in this database,
		the user guide, and other documentation.

		For an introduction, the tutorials, and the introductory seminar, see:

			qef-intro -- introduction to qef
			seminar(x-qmisc) -- An introduction to QEF seminar slide set
			qef-tuts(x-qmisc) -- command line and GUI tutorials

		See also: qef(1) qef(-x) qvrs qsg qefdirs

	 qefdirs  qef script generator for multiple directories
		qefdirs is one of the two major script generators of the qef system.
		It processes a simple list of directories and a list of their
		constructions and creates a qef/mimk script that provides facilities to
		invoke constructions by group (e.g., Local, Install, Man), or by
		individual directories (e.g., cmd~I, man~M).

		It also supports division of the directory list into different levels
		that can be invoked individually or in ranges.

		Note:	The input syntax is described by qefdirs's -X flag.

		See also: qefdirs-intro (x-qefdirs) qefdirs(1) qefdirs(-x)
			qefdirs.qh TreeList(x-qvrs) multidir-qef(x-qefeg)

	 qefgui  run the qef qui
		qefgui is a Tcl/Tk application that provides facilities to: navigate
		project trees; invoke qef and other tools; access the qef documentation
		(such as this); interface with the versioning system, create, delete
		and modify files; and create, delete and modify project trees.

		See also: qefgui(1) qefgui(-x) x-qefgui qefgui-intro

	 qefinfo  run the qef info tool
		qefinfo is just the qefgui program, but limited to the Qef-Info-Tool
		window. It is provided for use on systems for which qefgui is not
		provided.

		See also: qefgui

	 qefpp  the qef macro processor
		qefpp is not a separate program.  Rather it is a subroutine of qef
		itself which preprocesses scripts much like cpp in the C compiler.

		Even though qefpp is not a tool, as an important phase of the qef
		process it is given an external identity, an albeit brief entry
		in this tool database, and its own x_db database x-qefpp.

		See also: qefpp(x-qefpp) (x-qefpp)

	 qenv  output environment variables in sorted usable form
		qenv without any arguments, outputs the entire list of
		environment variables as a series of `=' statements.
		Alternatively the -c flag can be used to specify that the csh
		format is to be used.

		If arguments are specified, they should name environment variables
		to be output.

		Note:	qenv duplicates some of the functionality of the AT&T env
			and the BSD printenv, but qenv is consistent and
			provides the ability to select individual variables.

		See also: qenv(1) qenv(-x) env(1) printenv(1)

	 qfunc  output selected qfunc function/alias file
		qfunc is yet another bp link.  When invoked with an argument X,
		qfunc searches for a file called Qfunc.dir/X in the directories
		named by $PATH.  If found and the first four characters of the file
		are `#QF' followed by a tab, the file is copied to the standard output
		after replacing certain `%.' sequences by special run-time values.

		qfunc was implemented to facilitate the setting of useful csh and sh
		aliases or functions.  For example, the command:

			qfunc qd

		outputs:

			qd () {
				qdtmp=$(qds -d $*) && cd $qdtmp
			} # in sh, ksh or bash

		which is the definition of a shell function `qd' which facilitates
		chdiring to directories retrieved from the qdsrv using the qds
		interface.  To perform the definition within the current shell one
		would use:

			eval $(qfunc qd)

		Note that:

			qfunc -c qd

		delivers the equivalent alias for csh.  If qfunc is invoked without
		arguments, it outputs a list of the available qfunc files and their
		brief descriptions.

		Currently the provided functions are:

			Ev	function to invoke envset for selected set
			Qf	function to eval qfunc for selected function
			cats	function to invoke cat on file(s) found using sls
			eds	function to invoke $EDITOR on file(s) found using sls
			pdirs	pushd and popd implemented with pdirs
			qd	function to chdir using qds selection
			qdp	function to pushd using qds selection
			qdpush	function to pushd using qds selection

		See also: qfunc(1) qfunc(-x) bp howto

	 qgdiff  graphical file difference viewer
		qgdiff presents the differences between two argument files -- as
		determined by diff -- graphically.  The two files are displayed
		side by side showing the changes, deletions and insertions
		in coloured segments.

		See also: qgdiff(1) qgdiff(-x) diff(1)

	 qhost  qtree host server
		qhost is a server used by qremote to retrieve the target host's
		@System[Name] value, the host's $QTREE, and the user's home
		directory on that host.

		It should be started at boot time using something similar to
		rc.d/qhost.

		To start qhost, run:

			qhost -S
		or
			qhost -R # if address still in use

		qhost can be used as a client as in:

			qhost -v host	# retrieve version info of running server
			qhost -q host # cause host to quit
			qhost -u user host	# retrieve home directory for user
					# and $QTREE on named host

		The normal qhost output for the -u flag or as default is:

			host: @System[Name] <qtree-path> <login-dir>

		Note:	The <login-dir> is $Home[] for the user if defined.
			Otherwise getpwnam(3) is used to retrieve the passwd
			information for the user.

		See also: qhost(-x) qhost(1) qremote qdsrv qhost-setup rc.d/qhost

	 qhy  report why a target was rebuilt
		qhy examines the mimk history file qmkhist._ and outputs selected
		information concerning the argument files, such as the time and
		the reason it was last re-built.  A flag (-r) specifies that qhy
		is to recurse through files that forced the rebuild.  Another flag
		(-d) will list all the files on which a file depended and give
		their current times.

		Note:	qhy reports only that information available in the qmkhist._
			file or by examining the file system to retrieve current
			times for relevant files.  The information it reports, such
			as the dependency list may have since been changed.

		See also: qhy(1) qhy(-x) mimk qmkhist._

	 qlex  interface to lex
		qlex is an interface to lex that moves lex.tab.c to appropriate
		location and optionally converts `yy' variables.

		The qlex flags for file.l are specified by the qvrs variable
		_F_lex[file.l] (see _F_*).

		The actual program to be run is specified by _T_lex(x-qvrs).

		See also: qlex(1) qlex(-x) qyacc

	 qmsdev  Microsoft Developer's Studio project file generator
		qmsdev process the qvrs files to produce the proj.dsp, proj.dsw,
		and a command file runqef.bat.

		These files are required by the Microsoft Visual Studio integrated
		development environment. For details on how to use this command, see
		qmsdev(1)

		See also: qmsdev(1) qmsdev(-x)

	 qmsg  send a message or mail to designated users
		qmsg sends a single line message specified by either arguments or
		read from the standard input to the specified users.  The message
		is sent to the user's terminals (if they are logged in) or as mail.
		A flag (-m) is provided to force mail to be sent.

		qmsg is provided as part of the Q-Tree product as it is used by go to
		report that a job has completed.

		See also: qmsg(1) qmsg(-x) go josh

	 qremote  run a command on a remote host (if necessary)
		qremote is used to run commands remotely, if necessary.  Basically
		qremote creates and executes a shell command that executes the argument
		command on the appropriate host after the necessary setup (e.g., the
		setting of $QTREE and $PATH.  If the command is to be run locally,
		qremote will execute:

			<Host-Q-Tree>/bin/cush -Q -E env-set \
				-d dir [ go -d ] command ...

		If the command is to be run remotely, qremote will execute:

			<remote-sh> host <Host-Q-Tree>/bin/cush -Q \
				-sHOME=<home> \
				-E env-set -r dir [ go -d ] command ...

		<remote-sh> will be ~/.qtree/qremote/<host>, <Q>/data/qremote/<host>,
			or rsh(1), rcmd(1), or remsh(1) (whichever is provided).

		<home>: The user's home directory on the target host retrieved
			from qhost server.  This is required as Windows does not
			set $HOME properly in some cases.

		<Host-Q-Tree>: the location of the target hosts's <qtree-root>, as
			named by -q argument, retrieved from qhost, or /usr/qtree.

		-E env-set: The named envset should set $PATH, $QTREE and
			other necessary environment variables.  The envset can
			be specified via qremote's -E flag or @QremoteEnv.
			The default is "qremote".

		Distributed Processing Support:
		qremote supports a -Sservice option which is used to distribute
		processing over selected hosts.  If the -Sservice option is specified,
		qremote retrieves the value of @_Servers_[service] which should
		name the hosts that provide the specified service.

		qremote uses the qhost server that should be running on the named
		hosts to check that the target hosts are running and to retrieve the
		default <qtree-root> and the user's home directory.

		qremote then sends a "cycle" message to qdsrv to select the least
		recently used host (according to previous "cycle" messages).

		The hostname returned by qdsrv is then used as the target host.

		See also: qremote(1) qremote(-x) BuildHost(x-qvrs) QremoteEnv(x-qvrs)
			Remote-Qefs envset cush qhost qdsrv _Servers_[]

	 qrep  another grep
		qrep is yet another version of grep(1).  qrep uses regular expressions
		equivalent to that used by many Q-Tree tools such as qsg and qvrs.
		This version of regular expressions offers a number of features
		not offered by other implementations -- see regexp(x-qmisc).

		qrep also supports a number of features not offered by other greps
		such as multiple patterns and the specification of the files to
		be processed via the standard input or the argument files.

		Note:	qrep used to be called rep.

		See also: qrep(1) qrep(-x) rep rpl grep(1) regexp(x-qmisc)

	 qsg  the primary qef script generator
		qsg is the primary qef script generator -- see qsg-intro(x-qsg).  Its
		major purpose is to convert simple statements of intent into the
		input to the specified backend.  Extensive documentation of the
		syntax, semantics and available qsg script may be accessed using x-qsg.

		Note:	The default input to qsg is the contents of the directory's
			qeffile following the Begin line.

		See also: qsg-intro qsg(1) qsg(-x) x-qsg (x-qsg) qef qsgcomp qsgdump
			vci qmsdev

	 qsgcomp  compiles a qsg script to object
		qsgcomp compiles a qsg script to a p-code representation.  qsgcomp
		is usually used only to create qsg object files for inclusion in
		a qsg library such as the default library std.qsl.

		See also: qsgcomp(1) qsgcomp(-x) qsg qsgdump std.qsl(x-qsg) 	(x-qsg)

	 qsgdump  dump a qsg object file
		qsgdump is a debugging and documentation aid for the qsg script
		programmer and user.  Options exist to dump a qsg script's object
		code, summary, strings, header, or source.

		Note:	The standard library std.qsl is searched for the argument
			files before checking for a file, hence:

				qsgdump -S hanoi

			will output the source for the hanoi script.

		Also note that qsgdump will compile its argument files if they
		are not qsg object files.

		See also: qsgdump(1) qsgdump(-x)

	 qsh  qef shell command interpreter
		qsh is yet another shell command interpreter specifically provided to
		execute shell scripts generated by qef script interpreters such as
		qsg.  For some directories, such as the file system integrity check
		directory, qsh will serve as the backend interpreter instead of make,
		mimk, or qmk.

		qsh is used instead of sh as qsh provides a better echo facility, can
		be made to ignore the exit status of selected commands, and checks
		the $QEFHALTFILE file to determine if the qef session is being halted.

		See also: qsh(1) qsh(-x)

	 qtreeinfo  output information on $QTREE and its directories
		qtreeinfo outputs something similar to the following:

		$QTREE: /p/qtree/8.3/linux2_0i
		Default $QTREE: /usr/qtree

		0: /p/qtree/8.3/linux2_0i
			Real Dir: /p/qtree/8.3/linux2_0i
			Qtree(full) 8.5(567) - Linux-2.0.34-i686(linux2_0i) - 2000/04/14
			dt on gobo in /p/qtree/linux2_0i/o8.3

		The first line is the current value of $QTREE.
		The second line is the default value for $QTREE.

		This is in turn followed by a set of lines for each directory named
		by $QTREE.  This consists of the directory index, the name used,
		the real name of the directory, and the relinfo file contained
		in that directory.

		See also: qtreeinfo(1) qtreeinfo(-x) $QTREE relinfo

	 quete  list x_db topics and quete.db entries that match patterns
		quete is a specialized search tool that searches the title lines
		of all the x_db databases it can find (such as this one) and the
		quete/*.db database (as built using mkquete) and outputs the
		matched lines.  One of the flags it supports is -t which causes
		the output to be done as a Tcl/Tk list for direct loading into the
		Topic window of the qefgui Info Tool window.  The output includes
		Tcl/Tk tags to allow direct loading of a listed topic by clicking
		on the manual or x_db reference.

		The Apropos button in the Info Tool window invokes quete.  For
		example try: ? manual.

		quete supports the following flags that may be useful in queries:

			-Q		limit search to $QTREE manual sections
			-X		limit search to x_db databases
			-M		limit search to manual sections
			-N		Do Not do dual case pattern matching
			-<num>		limit output to <num> items
			pattern ...	patterns matched against lines -- Note if a
					pattern contains ` & ', it is split into
					multiple patterns.

		Note:	quete is a french noun for quest, search, collection,
			and beating about.

		See also: quete(1) quete(-x) x_db mkquete quete/*.db
			Qef-Info-Tool(x-qefgui)

	 qvrs  process the qvrs files
		qvrs is the major parameterization system of the qef system.  Due to
		its importance there is a x_db database dedicated to its description.

		See qvrs-intro(x-qvrs).

		qvrs is invoked by many of the qef tools to retrieve settings and
		controls.  It finds and processes the root.vrs, tree.vrs, qeffile
		and leaf.vrs files for the current directory.  The -p option writes
		out a `compiled' list of all the settings.

		To avoid repetitive execution of qvrs within a single qef run, qef
		executes qvrs -p saving the output in a temporary file, the name of
		which is assigned to the environment variable $QVRS_FILE.  Any
		program that needs qvrs settings checks this variable first, and if
		set, reads the named file directly.  Otherwise, the tool invokes qvrs
		-p and reads the output from the connecting pipe.

		In the absence of any arguments or flags, qvrs outputs the current
		settings.

		See also: qvrs-intro(x-qvrs) qvrs(1) qvrs(-x) qef x-qvrs (x-qvrs)

	 qvrsdmp  process qvrs binary file
		qvrsdmp processes the output produced by qvrs when the -p flag is
		specified.  The file is read and the symbol table is written to the
		standard output.  The file to be processed is named explicitly by
		argument, by $QVRS_FILE or by actually executing qvrs -p.

		See also: qvrsdmp(1) qvrsdmp(-x) qvrs

	 qvrsexpr  evaluate and output qvrs expressions
		qvrsdmp evaluates its argument expressions as qvrs expressions and
		outputs the results, one line per argument.

		This is equivalent to running qvrs with the same arguments, except
		that if a -f qvfile parameter is specified or if $QVRS_FILE is
		specified, the named file is taken to be the name of the qvrs binary
		file as produced by qvrs.  By directly loading the database from a
		file, the file system searches and the interpretation of those files
		done by qvrs -- which can be expensive -- are avoided.

		qvrsexpr was created for use within the graphical user interface.

		See also: qvrsexpr(1) qvrsexpr(-x) qvrs qvrsdmp qvrsexpr(x-qsg)

	 qyacc  interface to yacc
		qyacc is an interface to yacc(1) that moves y.tab.c to appropriate
		location and optionally converts `yy' variables.

		qyacc was created to make processing yacc files a single command.

		The qyacc flags for file.y are specified by the qvrs variable
		_F_qyacc[file.y].

		The actual program to be run is specified by _T_yacc(x-qvrs).

		See also: qyacc(1) qyacc(-x) qlex _F_qyacc(x-qvrs) yacc(1)

	 r90  reflect lines around diagonal
		r90 reads the argument files (defaults to the standard input) and
		outputs the result of reflecting the lines around the main diagonal.
		This has the effect that the first output line consists of the first
		characters of the input lines, the second output line consists of the
		2nd character of each input line, and so on.  Blanks are used where a
		character is missing (i.e., the line corresponding to the position is
		shorter than the maximum length line).

		Flags are provided to: trim leading spaces and tabs on input (-l);
		trim trailing spaces and tabs on input (-t); reverse input lines
		after padding to same length (-r); pad output lines to the same
		length (-p); trim trailing spaces on output (-T); and reverse
		output lines (-R).

		r90 has a number of interesting applications which are not easy with
		the standard tools, such as:

			r90 -pt | r90		# right pad to same length
			r90 -rlpt | r90 -R	# left pad to same length
			r90 -ptR | r90 -T	# reverse order of lines in file
			r90 -rptl | r90 -R | r90 # create column headings
			(r90 -p f1; echo; r90 -p f2) | r90 -T # join files together

		The -X flag lists the above as well as how to use r90 to perform the
		eight rotations and reflections that can be performed on an input file.

		See also: r90(1) r90(-x)

	 rc  windows resource compiler
		rc is a shell script provided by Interix that compiles windows
		resource files.  Further documentation may be available in the
		//C/Interix/man.

		See also: rc(1)

	 rcslocks  report the RCS locked files in a directory
		rcslocks reads its argument directory -- defaults to RCS -- to find
		any files of the form *,v.  Any such files are read to detect any
		locks.  If any locks are found the name of the base file (i.e., the
		file minus `RCS/' and the any `,v') is output.  A -l flag exists to
		specify that the locks themselves are to be listed.

		See also: rcslocks(1) rcslocks(-x) co(1)

	 realdir  output real directory name for argument directory
		realdir outputs the rooted and unambiguous pathname for the argument
		directory.

		realdir determines the real name for a directory by performing a
		chdir(2) to directory (if necessary) and then invoking getwd(3) to
		retrieve the true name.

		realdir is most often used to retrieve an unambiguous name for a
		directory that does not depend on symbolic or conditional links, the
		current universe, or special characters such as ~.  It is also used to
		avoid the inaccuracies that sometimes occur in the setting of $cwd
		or $PWD.

		See also: realdir(1) realdir(-x) pwd(1)

	 recur  execute a command repetitively
		recur executes its argument command repetitively, sleeping num
		(defaults to 3) seconds after each execution.  If the -i iterations
		was specified, recur terminates once the command has been executed
		that many times.  recur will also exit if -T (while true) flag was
		specified and the command returned a non-zero exit status (i.e., false),
		or if the -F (while false) flag was specified and the command returned
		a zero exit status (i.e., true).  Otherwise execution continues until
		the program is interrupted.

		One past use of recur was:

			recur -T qdsrv

		that is, run qdsrv repetitively until it successfully started, which
		it could not do until its port times out.  qdsrv has since been
		changed to have a -R flag that repetitively tries to connect to
		the port until it succeeds.

		See also: recur(1) recur(-x)

	 rep  another grep
		rep is an alias for qrep which is yet another version
		of grep(1).

		The rep name is historic.  It was replaced by qrep when
		a program called rep was added to linux.

		See also: qrep qrep(1) qrep(-x) rpl grep(1) regexp(x-qmisc)

	 resort  build new output in order specified by input
		resort uses the input file inputfile (defaults to the standard input)
		to reorder lines of other files, writing the resulting output to the
		standard output.  The lines of inputfile should be the same style as
		would be produced qrep with the -fo options.  Such lines consist of a
		file name, a block number (512 byte blocks), and a byte displacement
		within the block, separated by colons.  Text may follow a colon after
		the displacement.  resort reads this input, opens the file named
		on the line, seeks to the specified position, and copies the lines to
		the output from that point up to, but not including, the next line
		that matches the regex argument.

		resort is useful in reordering groups of lines according to some key
		on a distinguished line.  resort was written in 1976 to deal with
		sorting TIPs files and other multi-line database records.  Since that
		time, grpsort had been created to perform much the same task,

		See also: resort(1) resort(-x) grpsort qrep

	 revl  reverse input lines
		revl reads the argument files (defaults to the standard output), and
		for each input line, outputs the contents (excluding the newline) in
		the reverse order followed by a newline, to the standard output.

		See r90 for interesting applications of revl, in fact they
		were so interesting that revl was folded into r90.

		See also: revl(1) revl(-x) r90

	 rls  recursive list of files
		rls is a recursive ls(1) but with extended facilities for
		output field selection, selections of the depth of descent,
		selection of files and directories to be listed, etc.

		rls has a -F flag that allows the specification of fields to
		be output.  See lls(-x) or lls for a description of the fields.

		rls is used in FSIC package qef script to create lists of all files
		and/or directories in the selected tree.

		Note:	rls has a particularly useful -e flag which reduces the
			output list to those files matched by the argument pattern,
			somewhat like find(1)'s -name flag.  For example:

				% rls -sf -e'!SCCS/p\.'

			will limit the output to files */SCCS/p.*.

		See also: rls(1) rls(-x) lls FSIC

	 rmlist  remove files named in input
		rmlist reads its argument files or its standard input and removes the
		files (and optionally the directories) named by those inputs.

		rmlist is used to remove files and/or directories named by files.

		qef invokes rmlist to implement the Remove* directives.

		rmlist is also used in FSIC package qef script to remove empty
		files when lists have been generated.

		See also: rmlist(1) rmlist(-x)

	 rmnotnamed  remove all files not named by arguments
		rmnotnamed removes the all files in the current directory, that:

		* do not have names beginning with a `.' unless the -a flag is
		  specified;
		* are matched by one of the -p pattern options -- defaults to ``*''
		  (i.e., all);
		* are not named in the exceptions list;
		* are writable (unless the -f flag specified); and
		* are not directories.

		rmnotnamed is a dangerous command in that it will remove all the files
		in the current directory almost as easily as rm *, though it's more
		difficult to type.  It was created to facilitate cleaning up
		directories by removing all the files other than those explicitly
		named as in:

			% rmnotnamed qmkhist._

		See also: rmnotnamed(1) rmnotnamed(-x) rm(1) rmlist

	 rmwhite  output rpl script to remove redundant white space and newlines
		rmwhite reads its input files and creates the rpl input that would
		remove any trailing white space (i.e., spaces and tabs at the end of a
		line), the third and subsequent newlines in a row, and (if -l specified)
		extra newlines at the beginning and end of a file.

		See also: rmwhite(1) rmwhite(-x) rpl

	 rootvrs  create or modify the root.vrs file
		rootvrs is used to create an initial root.vrs file at the top of a
		source or object tree.  If a root.vrs file already exists, rootvrs may
		be used to modify a root.vrs file.  Furthermore rootvrs can update
		the current directory's root.vrs file to reflect changes in the
		root.vrs file of the ``parent'' directory (i.e., the next root in
		the RootPath).

		Normal root.vrs files contain typically contain the following:

			BuildHost -- name of the host used for qremote builds
			BuildSys -- type of host system (to check build validity)
			ConfigName -- name of the configuration
			ConfVrs -- name of the configuration file
			_DestDir_ -- the Destination directory
			EditBranches -- version control option forcing branches
			OldRoot -- old source root
			PrereqList -- list of prerequisite projects
			Project -- name of the product
			QefAdm -- name of the qef administration directory
			QremoteEnv -- envset to be used by qremote
			Revision -- default revision number
			RootAlias -- alias or alternative name for the root directory
			RootPath -- list of root directories
			SysVrs -- basename of qvrs file to be used host vars file
			TreedirsList -- name of treedirs input file list
			TreeType -- type of tree (e.g., baseline, working, object)
			TreeType[] -- types of other roots
			VCBranch -- displacement from VCRoot of files for tree
			VCMap -- the specification for mapping the repository to disk
			VCMap[] -- VCMap settings for other roots
			VCRoot -- root of the version tree (if not LastRoot)
			VCSys -- the version system

		See also: rootvrs(1) rootvrs(-x) root.vrs(x-qvrs) qvrs treedirs

	 rotf  select fields of input lines for output
		According to Stephen Lane:

			"Every good Q-Tree command uses rotf at least twice".

		rotf, which is pronounced `wrote-eff', reads lines from its input
		files (defaults to the standard input) or the files named within the
		argument files (if the -f flag is specified), breaks those lines into
		fields as delimited by the specified character (defaults to tab) and
		outputs the fields in the order and format specified by the selector.

		Purists might think that it duplicates some of awk(1)'s functionality,
		and it does, but in a much easier and more reliable way.  Furthermore,
		rotf predates awk and as such the author never learned to use the
		latter well.

		See also: rotf(1) rotf(-x) transl cut(1)

	 rpl  replace, print, or delete named lines
		rpl reads lines of the form:

			<file>:<address><action><text>

		The named file is opened and the actions are performed.  If the -r
		(for replace) flag is specified, the modified file is written back
		into the original file.  Otherwise the modified file is written to
		the standard output.

		The actions include line insertion, deletion, replacement, and output.

		A common scenario is to use qrep (or grep(1)) to extract lines from
		a set of files, modify the retrieved lines and use rpl to replace the
		original lines.

		getlist(1), which may not be available, was created to get for
		editing the files named in rpl input.

		Note:	There are many programs that generate rpl format such as
			qrep, lines, findc, rmwhite, cerrs, and clump, to name a few.
			Usually they support a -r flag to specify rpl style output.

		See also: rpl(1) rpl(-x) qrep

	 rtabs  align fields by inserting padding
		rtabs reads lines from the argument files (defaults to the standard
		input) and outputs the fields of the input lines padded and aligned
		(by inserting blanks or dots) as specified by an argument.

		The fields are delimited by a specified character (default tab) or
		white space.  The output format specification supports right or left
		justification.  rotf and transl are very useful when preparing input
		for rtabs as they can provide the facilities to skip or reorder fields
		or to insert arbitrary characters, which rtabs does not.

		See also: rtabs(1) rtabs(-x) rotf transl

	 samefile  check if two paths refer to same file
		samefile tries to determine if the two argument pathnames (the second
		defaults to ``.'') refer to the same existing file.  The stat(2)
		struct for both paths are retrieved using stat(2).  If either file
		does not exist, program exits with a -1 status.  If either the inode
		numbers (st_ino) or the device numbers (st_dev) differ, program exits
		with a status of 1.  Otherwise program exits with a 0 status.

		If the -v flag is specified, the first detected difference or the
		assumption that they are indeed the same file is output to the
		standard output.

		Warning:	There are pathological cases in which samefile
			will incorrectly report the files are different (e.g.,
			pathnames incorporate different mount points thus rdev
			is different).  Furthermore, samefile might not work
			on Windows as the inode number itself is not stable.

		See also: samefile(1) samefile(-x) stat(2)

	 sdba  output statistics about sdbm database
		sdba outputs information about the blocks of the specified argument
		DBM database.

		The first line is the block size as in:

			Block Size=4k

		For each non-empty block in the .pag file a line of the following form
		is output:

			#0: 53 entries; 91% used; 82 free

		For each empty block, sdba outputs:

			#16: no entries.

		See also: sdba(1) sdba(-x) ldbm kdbm

	 setbytes  set specified offsets to strings
		setbytes copies its argument input file (defaults to the standard
		input) to a temporary file /tmp/set??????.  Then, for each argument
		offset value pair, setbytes seeks to the specified offset of the
		temporary file and writes the value string.  Options to take or drop
		parts of the input file are also supported.

		setbytes can be very useful, but is provided to facilitate setting
		the name of the database in the sysnm binary.  See sysnm(1) for a
		description of how setbytes is used.

		See also: setbytes(1) setbytes(-x) fndstr sysnm

	 sfdchk  check strfix dictionaries for valid patterns
		sfdchk (StrFix Dictionary CHecK) reads strfix dictionaries and checks
		the values assigned to variables for validity as specified by an
		input specification.  This specification consists of the records
		containing three fields -- the variable, a regular expression (see
		regexp), and an understandable explanation of the legal values.
		For example, the following specification:

			KEEPFIDS  ^-/^[0-9]+$/  an unsigned number

		specifies that the value assigned to KEEPFIDS must be empty (the
		special interpretation of the `^-' or a string of digits).

		sfdchk compares each variable setting in the input dictionaries to
		ensure that their assigned values match the associated regular
		expression.  Any discrepancies are reported.

		See also: sfdchk(1) sfdchk(-x) strfix regexp(x-qmisc)

	 sfsic  source file system integrity check and db maintenance
		sfsic is used to compare the lists of existing source and version
		system files against the FSIC files.fl list.

		Typically sfsic is used in the fsic(x-qsg) script to create the ,s.errors,
		,s.tmps, and ,s.pfiles files which should be used to correct any
		discrepancies.

		See also: sfsic(1) sfsic(-x) FSIC(x-qfsic) files.fl lib/sfsic.cf

	 shfix  process input file incorporating output of embedded commands
		shfix copies its argument files (defaults to the standard input) to
		the standard output, processing any lines that begin with a `~' to
		perform special functions.  The most important special function is to
		incorporate the output of a shell command.  Other functions provide
		facilities to build those shell commands and to incorporate the names
		or versions of files and the values of argument registers into the
		output or the shell commands.

		The shfix -X flag describes the input file syntax.

		See also: shfix(1) shfix(-x) shfix(x-qsg)

	 shuffle  shuffle input lines and output
		shuffle reads in a list of lines or words (as specified by flags),
		shuffles the list, and outputs the result.

		Useful for testing.

		See also: shuffle(1) shuffle(-x) rand(3)

	 sls  source path ls
		sls outputs a list of all the files in the source path (as
		specified by SrcPath in qvrs files), eliminating those files
		for which a file with the same basename exists in an earlier
		directory, or for which another file can be assumed to be the
		source (e.g., x.y is source for x.c).  The -s flag also reduces
		the output to those files that have suffixes named by the @Suffixes
		variable or in the default string.  sls is the default srclist._
		generator.  The following is the command used by default for
		qsg scripts (unless overridden by setting SLScmd).

			sls -Ls

		The -L flag specifies the output is saved in srclist._ and changes
		to the file are reported.

		See also: sls(1) sls(-x) SrcPath(x-qvrs) Suffixes(x-qvrs) _F_sls(x-qvrs)
			_SuffixRules_[-defl] _SuffixRules_[] SLScmd(x-qvrs)

	 snm  standardized nm output
		snm provides a consistent interface to extract symbol table
		information from the argument files and output it in a simple and
		consistent manner no matter what the host environment and/or operating
		system (we hope).

		Unfortunately nm(1) is a program that has been subject to great
		changes of the years.  For some reason various suppliers lost sight
		of the fact that nm output should be grepable and processable
		by other tools.  snm is an attempt to retrieve a consistent
		and simple listing of the symbols in an executable, object file,
		or a library.  snm uses trait SNM_CONTROLS to specify the
		command to be run to get the initial symbol table.

		snm then processes that input to produce a standard form.

		Note:	Given some versions of nm(1) do not prefix their output
			with the name of the file being processed if there is only
			one argument file, snm attaches <Q>/lib/fakeobj.o to the
			argument list.

		See also: snm(1) snm(-x) liborder nm(1) topolsrt SNM_CONTROLS
			<Q>/lib/fakeobj.o

	 srclist  check the srclist._ file
		srclist reads a list of file names from the standard input or as named
		in the argument files and compares that list against the file list
		contained in the file srclist._.  If files named in srclist._ are not
		named in the input list, or vice versa, these discrepancies are
		reported and a new copy of srclist._ is created.

		srclist is actually a special case of filelist that is equivalent to:

		        filelist -fmnuv srclist._

		srclist was created and used to maintain the srclist._ database used
		by qef and its script generator qsg.  The default source database
		command used to be:

		        sls -s | srclist

		A full description of the above command is given in qef(1).  However,
		due to efficiency considerations, srclist's functionality has now been
		added to sls directly.

		See also: srclist(1) srclist(-x) filelist sls

	 strfix  replace variables according to replacement dictionary
		strfix is used to transform a prototype file into a configured file
		by substituting embedded variables with values assigned to those
		variables in a dictionary file given as an argument to strfix.

		It is used frequently within qef systems to create configuration
		specific header and data files.

		Note:	The strfix -[tT] flags specify that ~xx symbols are
			to be replaced by the bound characters.  See tilde-keysyms
			and tildes, and $OldTildeConversions.

		See also: strfix(1) strfix(-x) finclude tildes strfix(x-qsg)

	 sttyek  set or display saved stty erase and kill chars
		sttyek, in the absence of flags, sets the terminal's erase, kill,
		intr, and quit characters to those contained in the file .qtree/sttyek
		in user's login directory or in $HOME if user not specified.  If the
		-s flag is specified, or if the effective user's .qtree/sttyek file
		does not exist, the current settings for these characters are written
		out to the .qtree/sttyek file, before changing the settings.

		sttyek's major function is to provide an easy mechanism for users to
		preserve their preferred stty(1) controls in a way that is easy to modify
		and invoke.

		Another major application of sttyek (and its original motivation) is
		to temporarily set the terminal to your preferred settings while you
		are using someone else's terminal while saving the user's settings for
		easy restoration.

		See also: sttyek(1) sttyek(-x) stty(1)

	 subdist  create sub-distribution from master file lists
		The command:

			subdist -f subspec flist

		reads subspec (defaults to the standard input) as a specification of
		files and directories to be extracted from the input flist (defaults
		to the standard input) and outputs the selected files to the standard
		output. The flist file should contain white space separated pathnames.
		For obvious reasons subspec and flist may not both be defaulted to
		the standard input.

		The syntax and semantics of subspec is explained in subdist(-x).

		subdist is most often used to extract sub-distributions from a
		full distribution list.

		See also: subdist(1) subdist(-x)

	 summarize  summarize selected fields
		summarize extracts selected input line fields, maintains running
		totals for lines with common control fields and outputs the summary.
		In many ways it is just yet another implementation of the standard
		data-processing summarize process.

		See also: summarize(1) summarize(-x) sumup

	 sumup  output summations of selected input fields
		sumup sums up input numbers.  It reads the argument files (defaults to
		the standard input) and computes the totals for the selected fields of
		numbers. The selected fields are specified by the -[0-9] flags
		(default all read fields).

		See also: sumup(1) sumup(-x) summarize

	 suprep  suppress repeated fields
		suprep copies its input files to the standard output suppressing
		repetitions of selected fields and performing some additional output
		massaging when the selected fields change.

		Note:	rotf is useful in preparing input for suprep.  ffill is almost
			suprep's inverse.

		See also: suprep(1) suprep(-x) rotf ffill

	 sysnm  output symbolic system name or check if it matches arguments
		sysnm outputs or tests the symbolic name of the current operating
		system (System[Name]) according to a line in sysnames.tab selected
		by a search done using uname(1) strings.

		sysnm is equivalent to the command:

			system -n

		sysnm is a link to system, and if invoked using a name that matches
		*sysnm, the -n flag is assumed.

		Note:	To facilitate the determination of the type of system at
			login, prior to setting $PATH which may itself depend on sysnm,
			sysnm should be copied to a directory in the initial
			$PATH such as /bin or /usr/bin.

		See also: sysnm(1) sysnm(-x) sysnames.tab system System(x-qvrs)

	 system  output system name or check if it matches arguments
		system outputs or tests the name of the current operating or host
		system according to names specified by a line in <Q>/data/sysnames.tab,
		which is selected by pattern matching the catenation of the uname(1)
		system, release, and machine fields.

		The default output is the same as the value of the qvrs variable @System,
		the eight field of the sysnames.tab line.

		system is sometimes used in shell scripts, as described in system(1),
		to select actions based on the system.

		sysnm is a link or copy of system that assumes the -n flag which
		outputs the short symbolic system name.  If system is invoked using a
		name that matches '*sysnm', the -n flag is assumed.

		See also: system(1) system(-x) sysnames.tab sysnm System(x-qvrs)

	 tabrpl  replace tabs by spaces or vice versa
		tabrpl reads the argument files, converts all tabs to the appropriate
		number of spaces and outputs the resulting lines to outfile --
		defaults to the standard output.

		The processing is inverted by the -i or -I flags.  If the -i flag is
		specified, leading white space is converted to the appropriate number
		of tabs and spaces.  The -I flag converts all multiple spaces that can
		be converted to tabs.

		See also: tabrpl(1) tabrpl(-x)

	 tchown  change ownership and mode according to a template
		tchown changes the ownership and protection of files according to a
		template given in its file arguments, or the standard input if file
		arguments are not given.  tchown is intended for use after
		transferring a set of files to a new system or for ensuring that files
		and/or directories exist and have the correct ownerships and modes at
		the end of an installation.  The instal program records its chown(2),
		chgrp(2), and chmod(2) errors in tchown input format -- see instal(1).

		When instal installs a file with special modes or settings that cannot
		be set due to permissions, and the -I flag was specified, the failure
		is recorded in the file named by InstLog (with the `.log' replaced by
		`.fix'). The actual problem is recorded using tchown input format, thus
		facilitating quick rectification by applying tchown to the .fix file.

		Note:	If rls(1) or lls(1) are available the format `bUGf'
			produces output lines in the tchown input form.

		See also: tchown(1) tchown(-x) instal _F_instal(x-qvrs)
			InstLog(x-qvrs) lls instal chstat wmode

	 tdbkeys  list TIPs database index keys and/or files
		tdbkeys outputs the list of keys for the selected TIPs database dbase
		(default ``db'') which should have been constructed using tdbm.

		See also: tdbkeys(1) tdbkeys(-x) tdbm tdbrg

	 tdbm  create TIPs key files
		tdbm builds a DBM database.  The keys are the fields named in the
		argument taglist (defaults to the name tag).  The data items are the
		file name and offsets required to load the associated TIPs item.

		See also: tdbm(1) tdbm(-x) tdbkeys tdbrg

	 tdbrg  apply trg program against selected TIPs DBM database entries
		tdbrg extracts entries for the argument keys from the tdbm
		database dbn (default ``db'') and applies the -t argument trg
		program to selected entries.  trgmk is used to convert trg to object
		form if necessary.

		See also: tdbrg(1) tdbrg(-x) tdbm tdbkeys

	 ted  TIPs file editor
		ted is an interactive editor for TIPs format data.

		It allows the user to create new entries, reorder entries within a
		file, delete entries, and change individual fields within an entry.

		ted was the first program to use x_db to create an online
		documentation facility, in fact it was the motivation for x_db.  As
		such, there is extensive documentation available via the associated
		command x-ted which is invoked by the `x' command within ted.

		Note:	ted uses the leditor package.

		See also: ted(1) ted(-x) x-ted

	 termfnd  check if termcap/terminfo entry exists
		termfnd attempts to extract the termcap/terminfo entry for the
		argument term.  If no term argument is specified, $TERM is used.  If
		successful (i.e., the entry exists) termfnd exits with a zero status.
		Otherwise it exits with a non-zero status.  If there are multiple term
		arguments, the exit status is non-zero if any of the terms entries do
		not exist.

		Note:	termfnd is used to determine what leset input files can
			be processed.

		Note:	The tgetent(3) routines on some platforms are incapable of
			processing multiple calls, in which case the termfnd may
			illegitimately fail.

		See also: termfnd(1) termfnd(-x) leset tgetent(3)

	 termsa  list all Ada variables in files
		termsa outputs a sorted list of all the ADA variables found in the
		argument files (defaults to the standard input) in alphabetic order.

		A fuller description is given in termsc(1).

		Note:	termsa is often used to prepare a replacement dictionary
			for finda.

		See also: termsa(1) termsa(-x) termsc(1) finda

	 termsc  list all C variables in files
		The terms[cfwa] programs read the argument files (defaults to the
		standard input), and output a sorted list of all the unique terms, be
		it a C variable (termsc, a word (termsw), a field (termsf), or
		an ADA variable (termsa) in the input.

		terms[cfwa] are commonly used in combination with spell(1) and
		find[cfwa] to do spelling correction or cross reference maps.

		For example the following commands are part of the spelling correction:

			* Generate list of all words:
			termsw -n *.n | spell - > oldlist

			* Correct copy of word list:
			cp oldlist newlist; qed newlist
			# replace qed by your editor of choice

			* Create dictionary and find and replace producing rpl lines
			double oldlist newlist | findw -rn - *.n | rpl -vr

		double uses original and corrected list to create a replacement
		dictionary that is used by findw to find and correct the terms in
		the original files and produce rpl input which is used to change the
		original files.

		See also: termsc(1) termsc(-x) termsa termsf termsw findc rpl

	 termsf  list all tabbed fields in files
		termsa outputs a sorted list of all the fields found in the argument
		files (defaults to the standard input) in alphabetic order.

		A fuller description is given in termsc(1).

		See also: termsf(1) termsf(-x) termsc findf

	 termsw  list all words in files
		termsw outputs a sorted list of all the words found in the argument
		files (defaults to the standard input) in alphabetic order.

		termsw provides mechanisms for ignoring nroff commands, some
		punctuation, and capitalization, as does findw and commw.

		A fuller description is given in termsc(1).

		See also: termsw(1) termsw(-x) termsc findw commw

	 tf  output name of non-existent comma file
		tf outputs the name of a non-existent file in the argument dir
		directory. This file name will usually be used as a temporary file
		(i.e., a t.f.).

		tf writes ",X" to the standard output, where X is an alphabetic
		and the file ,X does not exist.  The X used will be the lowest
		letter in the range [a-zA-Z] for which the corresponding file does
		not exist.  The string is also output to the standard error output
		prefixed by "tf=".

		tf is commonly used to retrieve the name of a non-existent file
		to save the standard output of a command as in:

			% qrep pattern * > `tf`

		however, its use has been largely replaced by ct and pa as in:

			% qrep pattern * | ct

		ct also uses the comma convention.

		Note:	The Q-Tree frequently uses the comma prefix to
			indicate that the file is a temporary.

		See also: tf(1) tf(-x) ct pa

	 tildes  convert between symbolic and real character representations
		tildes reads files (defaults to the standard input) and converts any
		special character to its symbolic representation which is normally a
		tilde (`~') followed by two printable ascii characters.  The resulting
		output is written to outfile which defaults to the standard output.

		The list of ~XX symbols can be viewed using the -s flag or in
		tilde-keysyms.

		Note:	There are two translation tables: the one for the latin1
			characters used in xfig(1) and other X programs, and a
			possibly obsolete set used on DOS systems in the early
			nineties.  The old set is selected by the -O flag or
			by setting $OldTildeConversions.

		See also: tildes(1) tildes(-x) tilde-keysyms $OldTildeConversions

	 timeout  execute a program with a time limit
		timeout executes another program (command) and kills the program (with
		signal sig (defaults to KILL) if the time limit numsecs (defaults to
		10) expires.  timeout is useful in test suites to by-pass
		nonterminating processes.

		If the child command exits normally before the time out occurs, timeout
		exits with the status of the child process.

		See also: timeout(1) timeout(-x) kill(1) nohup(1)

	 tlist  formated listing of TIPs data base files
		tlist will list the contents of the specified TIPs files (defaults to
		``*.d'' files in current directory).

		Note: The listing formats provided by tlist are fairly weak.
			For more sophisticated formated output see trg.

		See also: tlist(1) tlist(-x) TIPs trg introtips(1)

	 tmkprof  create new TIPs data base profile
		tmkprof reads the argument file input (defaults to the standard
		input) and converts it to a TIPs profile in argument file obj
		(default .tprof).

		A TIPs profile defines the record tags and their types, constituent
		fields, and Mnemonics.

		The command:

			% bp tipsprof

		will output a prototype tmkprof input file.

		See also: tmkprof(1) tmkprof(-x) introtips(1) tprof

	 topolsrt  topologically sort input
		topolsrt takes a list of pairs of node names representing directed
		arcs in a graph and prints the nodes in topological order on the
		standard output.  Its major use is to order the modules of a library.

		topolsrt is a replacement for the program tsort(1) which attempts to
		perform the same task.  Unfortunately tsort does not detect
		overlapping cycles which are sometimes significant when trying to
		partition the nodes.

		See also: topolsrt(1) topolsrt(-x) liborder tsort(1)

	 touchfiles  list or create touch files
		touchfiles is used to list existing _Touch_ files, to list the
		directories of @TouchPath, or to create or touch new files.

		Basic commands are:

			touchfiles	# list all touchfiles
			touchfiles xx	# list all touchfiles for xx
			touchfiles -f	# list all touchfiles without times
			touchfiles -p	# list @TouchPath directories
			touchfiles -c xx # create or touch touchfile xx

		See also: touchfiles(1) touchfiles(-x) _Touch_ TouchPath(x-qvrs)

	 tprof  output TIPs profile in various formats
		For all options, other than the -N flag, tprof lists the structures
		of the argument TIPs profile files profile (default .tprof).

		Options are provided to get the profile information in a variety
		of formats -- see tprof(-x) include ones to produce C code and
		defines for insertion into special purpose applications such
		as contax.

		If there is more than one profile argument, the output for each file
		is preceded a line containing the name and a `:'.

		The -N flag is used to get a list of the TIPs profiles.

		See also: tprof(1) tprof(-x) tmkprof TIPs

	 traits  output traits table
		traits outputs the traits database <Q>/data/traits/<host>.tab.
		The traits database is a set of variable/value pairs used to store
		system, host, and site settings such as capabilities, pathnames, and
		special values like QDSRV_HOST.

		The data/traits/<host>.tab file is created by mktraits from the traits
		source files traits.vrs and traits.ext.

		Note:	Whenever mktraits -Ru is run, any traits/<host>.tab file
			that is older than either of the source files is removed.
			Running traits or any query of the traits database via the
			libdtree.a A.P.I. will recreate the file if necessary.

		See also: traits(1) traits(-x) mktraits trait(x-qvrs) trait(x-qsg)
			traits-vars traits/<host>.tab

	 transl  translate input fields
		transl reads its input lines, reformats (i.e., translates) them
		according to an argument format and outputs the result.  The format
		allows the selection of fields and arbitrary strings and characters.
		The -p pat flag restricts processing to those lines that match
		the regular expression pat.

		See also: transl(1) transl(-x) rotf

	 treedirs  mkdir selected or all sub-directories of a qef tree
		treedirs is used to create a shadow object or working tree.  Normally, it
		creates the directories for the files named in @TreedirsList (defaults to
		treedirs.lst in @TreedirsPath).  If such a file is not found, treedirs
		searches the @RootPath trees for the construction files.

		The -X flag to treedirs gives a complete description of the files it
		processes and creates.

		treedirs is usually the second step when one is modifying or building
		a system, the first being to use rootvrs.

		treedirs -L outputs the list of construction files for the argument
		directory tree.  The construction files are:

			qeffile
			qeffile2
			root.vrs
			tree.vrs
			suppress.vrs
			nobuilds.vrs
			noqfile.vrs

		The generated list can be saved in treedirs.lst (the default file
		read by treedirs).  Alternatively, treedirs can walk the directory
		tree itself looking for the files of relevance.

		See also: treedirs(1) treedirs(-x) treedirs.lst rootvrs mkqtree
			TreedirsList(x-qvrs) TreedirsPath(x-qvrs) ExcludeDirs(x-qvrs)
			suppress.vrs nobuilds.vrs noqfile.vrs

	 trg  template driven TIPs report generator
		trg executes trgmk to compile the template (if it is not an object
		file already), and then, for each entry that matches the query
		(default all entries) outputs, to the standard output, the template
		with the appropriate interpretation.

		trg is a TIPs tool for preparing data for other processing.  Many of
		the functions that may normally be found in information systems, can
		be provided by the creation of a template that selects and prepares
		data for other UNIX utilities.

		An x_db database x-trg

		Note:	trg scripts are often converted into C code using trgdmp
			and then embedded in applications such as contax, man3db,
			and parmsdb.

		See also: trg(1) trg(-x) TIPs x-trg (x-trg) trgdmp trgmk

	 trgdmp  print trg object file
		trgdmp dumps the argument trg object file (default t.out) in a readable
		form into outfile (defaults to the standard output).  It can also be
		used to convert an object file to a C declaration for direct inclusion
		in an application program (e.g., contax, man3db).

		See also: trgdmp(1) trgdmp(-x) TIPs trg trgmk

	 trgmk  compile trg script
		trgmk compiles the trg source file (defaults to the standard input),
		and writes the object code to object (default t.out).

		trgdmp can be used to dump a trg object file's code in the pseudo
		code or as a C initializations that can be embedded in applications
		such as man3db or contax.

		See also: trgmk(1) trgmk(-x) trg trgdmp TIPs trgmch(x-ltips)

	 tscan  interactive TIPs data base scanner
		tscan is the TIPs interactive query and scanning program.  See
		introtips(1).

		tscan allows a user to access the argument data bases with a variety
		of techniques.

		Note:	tscan is somewhat obsolete and clumsy and isn't used much.
			TIPs applications are largely to organize data for
			generation of other applications and hence tscan has
			been woefully ignored.

		See also: tscan(1) tscan(-x) TIPs ted

	 tstrhash  test strhash hashing
		tstrhash applies a strhash(x-ldtree) table against the input terms and
		outputs a variety of results that may be used to test the efficacy of
		the table with the given list of terms.

		tstrhash calls strhash(x-ldtree) to hash the lines (words if -w specified)
		of the argument files (defaults to the standard input) and
		outputs the resulting hash value and the argument string.

		tstrhash is used to test the hash table for a given vocabulary.  The
		objective is to look for a hash table that gives the lowest weight
		(i.e., fewest hash collisions for the given vocabulary).

		See also: tstrhash(1) tstrhash(-x) strhash(x-ldtree)

	 typset  interface to typesetter and printing packages
		typset is primarily an interface to the n/troff(1) family of programs.
		Its normal processing is to read the argument files, eliminating the
		``.so'' commands at the beginning of the input lines (as is done by
		elimso), piping the result to a constructed command to process and
		output the result.

		The processes to be applied to a document may be specified via
		command line flags, but typically one embeds a lines containing
		'TYPESET:' followed by the flags (see typset(-x)).  The process
		selection flags are:

			-d	do not apply elimso
			-e	process through eqn(1)
			-g	process through grap(1)
			-p	process through pic(1)
			-r	process through refer(1)
			-t	process through tbl(1)
			-f	process through form
			-mX	apply the -mX flag to the troff run

		typset provides a variety of actions selected via the -a flag.
		Typical actions would be:

			N	nroff
			P	print the document 2-up
			P1	print the document one up
			xpv	X preview the document

		A list of the supported actions is produced by the -A flag.

		The actions, special flags, tools to be applied for an action
		are all specified via <Q>/lib/typeset or $HOME/.qtree/typeset.

		See also: typset(1) typset(-x) elimso form $TYPESET ~/.qtree/typeset <Q>/lib/typeset

	 untouch  set file times
		untouch sets the last access and modification times of the argument
		files to a specified time, similar to the standard tool touch(1).
		untouch provides additional facilities such as setting the times
		to that of another file or to a specific date.

		See also: untouch(1) untouch(-x) touch(1)

	 upd  update conventionally named versions of files
		upd is used to rename files to create a pseudo version system. Given
		a file called eg, the command:

			upd eg

		where files eg-2, eg, eg+1, and eg+3 exist, upd will
		perform the following moves:

			mv eg+3 eg+4
			mv eg+1 eg+2
			mv eg	eg+1
			mv eg-2 eg-1

		If given a filename containing a `.', upd uses `o's (for old) and `n's
		(for new) to create old and new versions of a file, as in:

			file.nnc
			file.c
			file.oc
			file.oooc

		go creates an output file called ,.g but performs an upd-like
		renaming such as:

			mv ,.oog ,.ooog
			mv ,.og ,.oog
			mv ,.g ,.og

		See also: upd(1) upd(-x) go

	 upto  print selected lines from named files
		upto outputs lines specified by the input files  (defaults to
		the standard input).  The input lines should consist of a file name, a
		colon (`:'), and a line number, optionally followed by a colon and
		other text (i.e., rpl format).  upto finds the specified line,
		outputs it and outputs the lines up to (and including) the next line
		that matches the pattern specified by the -u (-l) flag.  If neither
		the -u or -l flag is specified, just the selected line is output.  If
		the -r flag is specified, the lines output are the file name, line
		number and line contents separated by colons (i.e., rpl format.  Each
		set of lines is preceded by the file name and the line number, unless
		suppressed by the -q or -r flags.

		upto is useful for extracting ranges of lines from multiple files.

		See also: upto(1) upto(-x) rpl

	 vcc  create, compile, link, and remove version string source file
		vcc is an interface to cc that prepares a version file and then
		invokes the argument cmd, replacing +VFILE+ by the created version
		file.  A typical use is:

			vcc -m mimk cc mimk.o +VFILE+ -ldtree

		vcc creates file _vmimk.c, which contains:

			char version[]={"V@(#)Mimk  6.3 - 95/06/23 03:59:36 - linux"};

		with the appropriate values for the version number and date (see
		mkvernum(1)).  The command `cc ...' is then run, with the `+VFILE+'
		argument replaced by _vmimk.c.  Upon completion, the version file is
		removed (unless the -k flag is specified).

		See also: vcc(1) vcc(-x) mkvernum MkvernumFormat _F_mkvernum_cc(x-qvrs)
			ReportMkvernum Revision RevisionString

	 vci  version control system interface
		vci is a qsg clone that provides basic version control facilities
		such as checking in or out a file, reporting what files are locked,
		outputting the differences between a current file and its version
		system release, and so on.

		These facilities are provided by two qsg libraries: vci and
		@VCSys (@VCSys is usually set in the root.vrs vile).  The vci
		library provides general utilities, whereas the @VCSys library
		provides the implementations of the various facilities for the
		specific version system.  The facilities provided should be:

			changed  list changed files (see cmdcmp)
			ci  check in argument files
			co  check out argument files
			diff  produce differences between file and its v-file version
			lock  lock the argument files
			new  create a new version administration file (v-file)
			novfiles  list files for which there is no v-file
			rlog  produce history logs for argument files
			tell  tell which files are checked out for edit
			unget  unget or uncheck out argument file, discarding changes
			vdiff  run qgdiff on argument files and their v-files

		See also: vci(1) vci(-x) qsg VCSys(x-qvrs)

	 vernumcomp  compress the mkvernum database
		The version database created maintained by qdsrv for mkvernum is
		usually <Q>/data/mkvernum.db.  Every time mkvernum, or its alias
		vcc is invoked a line of the following form:

			module version(count) system host directory user time

		is appended to the database, which will therefore be growing
		monotonically. If left unattended this database can get very big and
		loading it can be time consuming.  However, other than the last record
		for each module, which contains the last count for that module, most
		records are not required, other than for historic and auditing purposes.

		vernumcomp reads input, copying comments and the last record for
		each module in the database to its output.  It also appends its input
		to a savefile if specified.

		The following is a recommended procedure for compressing the database,
		while saving old records for possible future consultation.

			cd `pathto qt/data` # chdir to the qtree data directory
			gunzip mkvernum.odb # uncompress old record file
			qdmgt freeze # freeze the qdsrv until new file created
			vernumcomp -i- -o- -s mkvernum.odb # compress the database
			qdmgt reload # unfreeze the qdsrv
			gzip mkvernum.odb # compress the database

		See also: vernumcomp(1) vernumcomp(-x) mkvernum.db mkvernum qdsrv vcc

	 wcci  windows c compiler interface
		wcci is a program that provides a rational (i.e. Unix cc-like)
		interface to native compilers on Microsoft Windows systems.
		By default, it is configured to drive Microsoft's compiler and linker
		(CL.EXE and LINK.EXE) but it can also be configured to drive other
		compilers through the Wcci* qvrs variables. See wcci(1) for details
		on how wcci works and how it can be configured.

		See also: wcci(1) wcci(-x)

	 whats  whats 2 + 2
		whats evaluates its argument list or its input lines as
		arithmetic-expressions and outputs the results, possibly in a
		specified base.

		The expression may contain all the C binary, unary, and ?: operators
		that may be used on ints.

		See also: whats(1) whats(-x) arithmetic-expression(x-qmisc)

	 wmode  write-protect files
		wmode sets or resets the write mode bits of the argument files or
		the files named by the argument files or the standard input.

		Purists might object claiming that chmod(1) supports flag to do the
		equivalent, but the following is table of wmode flags and the
		chmod(1) equivalent:

			wmode	chmod
			-0	a-w	# actually -0 is the default
			-1	a-w,u+w
			-2	ug+w,o-w
			-3	a+w

		Furthermore, wmode can read its arguments from the standard input
		which is frequently useful as in:

			<pipeline> | wmode -f

		See also: wmode(1) wmode(-x) chstat fexists chmod(1) chmod(2)

	 wordidx  output input lines followed by lines indicating word count
		wordidx is used to indicate the indices and spans of sequences in the
		input lines that correspond to C variables, that is an alphabetic
		character or underbar followed by zero of more alphanumeric characters
		or underbars.

		For example, consider the output for input "Now is the time ...":
		
		    Now is the time for all good men to come to the aid ...
		                                        1
		    1__ 2_ 3__ 4___ 5__ 6__ 7___ 8__ 9_ 0___ 1_ 2__ 3__
		
		wordidx was created to quickly determine the index for a s(x-qed)
		command within qed.  In fact, using the leditor keymapping
		within qed, Shift FP5 is mapped to "^SoV6.>wordidx^J" which
		will show the indices of the words in the current line.

		See also: wordidx(1) wordidx(-x)

	 wot  output embedded sccs id strings
		wot searches the argument files, or the files named by files, or
		the standard input if the -f flag specified or the standard input
		(if no arguments or -f) for occurrences of the pattern that the
		SCCS program get substitutes for %Z% (i.e., @(#)) and prints
		out what follows up to the first `"', `>', newline, back-slash,
		or null character.  It also supports a -p flag which specifies that
		wot is to search $PATH for the files to be processed, and a -v flag
		that limits the output to strings beginning with `V@(#)'.

		Note:	mkvernum and vcc embed such strings into their products,
			thus wot may be used to determine the version of the tools
			being run.

		For example, the command:

			wot -vp qef qefgui

		will output the version strings for the $PATH's qef and qefgui.

		See also: wot(1) wot(-x) what(1) mkvernum

	 x-contax  contax use and data bases eXplanatory D.B.
		This x_db database contains items describing the contax system,
		its files and profile.

		See also: (x-contax) x_db(1) x_db(-x) contax

	 x-eml  form eml macros eXplanatory D.B.
		This x_db database contains items describing the form eml
		macro package: eml-mif, eml-man, and eml-xdb.

		See also: (x-eml) x_db(1) x_db(-x) form

	 x-form  form macros and syntax eXplanatory D.B.
		This x_db database contains items describing form, its syntax and
		primitives.

		See also: (x-form) x_db(1) x_db(-x) form

	 x-html  html qsg library eXplanatory D.B.
		This x_db database contains items describing the scripts of the
		qsg library <Q>/lib/qsg/html.qsl.  This library contains
		scripts to aid in creating HTML files.

		See also: (x-html) x_db(1) x_db(-x)

	 x-ldeps  deps library eXplanatory D.B.
		a
		This x_db database contains items describing the -ldeps library,
		which provides symbol table management used by incls and other
		programs.

		Bug:	It's still under development.

		See also: (x-ldeps) x_db(1) x_db(-x)

	 x-ldtree  x_db database describing routines of the -ldtree library
		Companies that use the full Q-Tree set of tools often use the man3db
		system to document subroutines and facilities of libraries.  Tips
		database entries describing the library's components are embedded in
		the C source files as comments.  The man3db program is then used to
		extract those comments and convert them from the TIPs format into a
		variety of products such as man3 sections in troff or frame, lint
		libraries, software inventories and x_db databases.

		x-ldtree and any other Q-Tree program whose name is of the form x-lname
		are x_db databases that describe the library -lname.

		Such databases can be examined using the qef gui by selecting those
		databases using the Databases button in the View pull down menu of
		the Qef Info Tools window.

		See also: (x-ldtree) x_db(1) x_db(-x) man3db

	 x-lledit  ledit library eXplanatory D.B.
		This x_db database contains items describing the routines of the -ledit
		library which are used to implement the leditor.

		See also: (x-lledit) x_db(1) x_db(-x) leditor

	 x-lqvrs  qvrs library eXplanatory D.B.
		This x_db database contains items describing the routines of the -lqvrs
		library which provide qvrs routines and expression manipulation.

		See also: (x-lqvrs) x_db(1) x_db(-x) qvrs

	 x-ltc  tc library eXplanatory D.B.
		This x_db database contains items describing the routines of the -ltc
		library which provide routines to output terminal control strings.

		See also: (x-ltc) x_db(1) x_db(-x)

	 x-ltips  tips library eXplanatory D.B.
		This x_db database contains items describing the routines of the -ltips
		library

		See also: (x-ltips) x_db(1) x_db(-x) TIPs

	 x-man  the -man macro set eXplanatory D.B.
		This x_db database contains items describing the troff(1) -man macros.

		See also: (x-man) x_db(1) x_db(-x) man(7) man3db

	 x-qed  qed commands and facilities eXplanatory D.B.
		This x_db database contains items describing qed flags, commands, errors,
		and other features.

		See also: (x-qed) x_db(1) x_db(-x) qed

	 x-qef  QEF facilities and tools eXplanatory D.B.
		This x_db database, of which this is an item, contains items describing
		the tools, features, macros, controls, and files of the qef system.

		See also: (x-qef) x_db(1) x_db(-x) qef

	 x-qefdirs  qefdirs eXplanatory D.B.
		This x_db database describes the syntax and semantics of the
		other qef script generator qefdirs.  Whereas qsg is for individual
		directories, qefdirs is for trees providing the glue to control
		builds over trees and sub-trees of directories.

		See also: (x-qefdirs) x_db(1) x_db(-x) qefdirs

	 x-qefeg  prototype qef files eXplanatory D.B.
		This x_db database contains a number of prototype qeffile files
		and example qvrs files.

		See also: (x-qefeg) x_db(1) x_db(-x)

	 x-qefgui  qef graphical user interface eXplanatory D.B.
		x-qefgui is an x_db database that contains items describing different
		aspects of the qef gui.  These items are displayed by the various
		help buttons within the gui.

		See also: (x-qefgui) x_db(1) x_db(-x) qefgui
			x_db(-x)

	 x-qefpp  qef preprocessor controls and macros eXplanatory D.B.
		This x_db(1) database describes qef preprocessor qefpp, its
		controls and macros.

		See also: (x-qefpp) x_db(1) x_db(-x) qefpp

	 x-qfsic  file system integrity (fsic) package eXplanatory D.B.
		This x_db(1) database describes FSIC (the File System Integrity
		Check) package, its tools, files, procedures, error messages, and
		corrective measures.

		See also: (x-qfsic) x_db(1) x_db(-x) FSIC
			fsic-intro(x-qfsic)

	 x-qmisc  Q-Tree miscellany eXplanatory D.B.
		x-qmisc is an x_db database that contains items describing different
		procedures and facilities of the Q-Tree system.

		Note:	Some of the other x_db databases will refer to items in this
			database.

		See also: (x-qmisc) x_db(1) x_db(-x)

	 x-qproc  software process procedures eXplanatory D.B.
		x-qproc is an x_db database containing items describing typical
		software procedures for a software product to be built using qef.x

		See Chapter 12.10 of the Guide regarding the creation of a company
		specific procedures manual.

		See also: (x-qproc) x_db(1) x_db(-x)

	 x-qsg  qsg and its support library eXplanatory D.B.
		This x_db(1) database describes qsg (the QEF Script Generator), its
		tools, input syntax, and the scripts of the standard qsg library.

		See also: (x-qsg) x_db(1) x_db(-x) qsg

	 x-qvrs  qvrs variables, facilities, and files eXplanatory D.B.
		This x_db database describes the files, syntax and features and many
		of the variables of qvrs(1).

		See also: (x-qvrs) x_db(1) x_db(-x) qvrs

	 x-ted  ted the TIPs editor eXplanatory D.B.
		This x_db database contains items describing the TIPs database editor
		ted features, commands, prompts, and errors.

		See also: (x-ted) x_db(1) x_db(-x) ted

	 x-trg  TIPs trg functions eXplanatory D.B.
		This x_db database contains items describing the TIPs trg keywords
		and functions.

		See also: (x-trg) x_db(1) x_db(-x) trg trgmk TIPs

	 x-tscan  tscan facilities and commands eXplanatory D.B.
		This x_db database contains items describing the prompts of tscan,
		the TIPs database user interface.

		See also: (x-tscan) x_db(1) x_db(-x) tscan TIPs

	 x-xfig  xfig qsg library eXplanatory D.B.
		This x_db database contains items describing the scripts of the
		qsg library <Q>/lib/qsg/xfig.qsl.  This library contains scripts
		to aid in creating xfig(1) files.

		See also: (x-xfig) x_db(1) x_db(-x) xfig(1)

	 x-zr  qed function library eXplanatory D.B.
		This x_db database contains items describing the qed functions.

		These functions are invoked using the qed command C(x-qed).

		The confusing name (i.e., "zr") is because the original way one invoked
		these functions was to use the 'r' register, hence the command would be:

			\zrfunction arguments ...

		See also: (x-zr) x_db(1) x_db(-x) C(x-qed)

	 x_db  x_db database front end
		x_db serves as the front end to an x_db (x for eXplanatory) database.
		For example this is the x-qef x_db database.  An important feature
		of x_db is that when invoked using the command x-Name, Name is taken
		to be the name of the database to be used.  x_db when invoked as
		x-Name, will search for DIR/Xdb.dir/Name.xo, where DIR is a directory
		named by $PATH.

		x_db databases are used to document many of the Q-Tree tools such as

		  x-contax  contax use and data bases eXplanatory D.B.
		  x-eml  form eml macros eXplanatory D.B.
		  x-form  form macros and syntax eXplanatory D.B.
		  x-html  html qsg library eXplanatory D.B.
		  x-ldeps  deps library eXplanatory D.B.
		  x-ldtree  x_db database describing routines of the -ldtree library
		  x-lledit  ledit library eXplanatory D.B.
		  x-lqvrs  qvrs library eXplanatory D.B.
		  x-ltc  tc library eXplanatory D.B.
		  x-ltips  tips library eXplanatory D.B.
		  x-man  the -man macro set eXplanatory D.B.
		  x-qed  qed commands and facilities eXplanatory D.B.
		  x-qef  QEF facilities and tools eXplanatory D.B.
		  x-qefdirs  qefdirs eXplanatory D.B.
		  x-qefeg  prototype qef files eXplanatory D.B.
		  x-qefgui  qef graphical user interface eXplanatory D.B.
		  x-qefpp  qef preprocessor controls and macros eXplanatory D.B.
		  x-qfsic  file system integrity (fsic) package eXplanatory D.B.
		  x-qmisc  Q-Tree miscellany eXplanatory D.B.
		  x-qproc  software process procedures eXplanatory D.B.
		  x-qsg  qsg and its support library eXplanatory D.B.
		  x-qvrs  qvrs variables, facilities, and files eXplanatory D.B.
		  x-ted  ted the TIPs editor eXplanatory D.B.
		  x-trg  TIPs trg functions eXplanatory D.B.
		  x-tscan  tscan facilities and commands eXplanatory D.B.
		  x-xfig  xfig qsg library eXplanatory D.B.
		  x-zr  qed function library eXplanatory D.B.

		See also: x_db(1) x_db(-x) xdbs xdbmk

	 xdbmk  create an x_db data base
		xdbmk converts a source form x_db database to the binary form.

		Note:	x_db and all its aliases such as x-qef, x-qvrs, and x-qsg
			support a -S flag which will output the source form of the
			selected items, hence:

				x-qef -AS

			will dump the entire source of this database, and xdbmk can be
			used to recompile it.

		Note:	xdbmk's -X flag outputs the syntax of the input language.
			To facilitate use, the input syntax is summarized here.

		Input format:

		%{ [key ...]	start of a major item -- keys beginning with `*'
				taken to be group names and duplicates not reported
		%{- [key ...]	start of a minor item
		%}		end of an item
		%A key ...	add addition aliases or keys for the item
		%D description	set the short description for the database
		%i file		include named file
		%%...		line beginning with literal %
		%# comment	comment line - ignored
		%c [key ...]	produce columns of selected keys (default major items)
		%l [key ...]	produce list of selected keys (default major items)
		%S ...		line is maintained in database but never output
				used to embed SID lines in source and binary
		%;		%; embedded in a text body is not output to facilitate
				use of unexpanded SCCS keywords (e.g., %A)
				for literal `%;' use `%%;;'
		%<tag str %;	If outputting for tcl, output str followed by tag;
				common tags are: manref, B (bold), I (italics), btn (button)
		... %?word	treat word (or up to %;) as manref as in word
		... %!word	treat word (or up to %;) as italics as in word
		... %$word	treat word (or up to %;) as bold as in word
		... %*word	treat word (or up to %;) as btn as in word
		... %% ... 	a literal % character

		See also: xdbmk(1) xdbmk(-x) x_db

	 xdbs  list all or specified x_db databases or all their topics
		xdbs is used primarily by the qef gui to retrieve the names,
		pathnames, and descriptions of all or specified x_db databases.
		It will also produce all the available topics for all or specified
		databases.  A flag is provided to cause the output to be formatted
		as TCL lists to facilitate processing within the qefgui.

		See also: xdbs(1) xdbs(-x) x_db

	 xfinterp  process -x flag outputs
		xfinterp reads its standard input which is assumed to be the output
		of Q-Tree programs run with the -x flag.  This input is processed
		to format the input to produce one of the following forms:

			* description lines with troff formatting (-d)
			* description lines (-s)
			* skeleton troff manual page (-m)
			* skeleton eml-form manual page (-f)
			* troff formatted form of -x outputs (default)
			* description lines (-d)

		One useful application of xfinterp is to produce a list of all the
		programs in Q-Tree bin using:
			cd `pathto qtbin`
			l -se | lash -lf "./%1 -x" | xfinterp -s

		See also: xfinterp(1) xfinterp(-x)

	 xtty  convert stty(1) output to full explanations
		xtty processes its input, which should be the output of stty(1) and
		converts it to a standard annotated representation.  For example, the
		following example stty output:

			speed 9600 baud; line = 0;
			erase = ^H;
			-brkint -imaxbel

		when processed by xtty is converted to:

			speed:          9600 baud
			line discp:     0
			erase char:     ^H
			-brkint:        does not signal INTERRUPT on break
			-imaxbel:       flush input buffer on overflow

		xtty is for those of you who cannot remember what "ofdel" means.

		See also: xtty(1) xtty(-x) stty(1)

	 younger  test if files younger than specified time
		younger compares the last modification time of the argument files or
		the files named by the files (if -f specified) against basefile's last
		modification time.  The names of any files that are younger than
		basefile are written to the standard output.

		rls has a -y yfile option that limits its output to those files
		that are younger than yfile.

		fexists has options to limits its output to those input pathnames
		that have been modified within a certain specified range.

		See also: younger(1) younger(-x) rls fexists

	 zfill  zero fill digit string
		zfill copies its argument files (defaults to the standard input) to
		the standard output, left zero filling a digit string immediately
		after a specified selector (defaults to the first colon) to a width of
		six columns.

		The default is to zero fill the field immediately after the first colon.
		This allows one to convert grep -n output to facilitate sorting of
		that output.

		See also: zfill(1) zfill(-x)
 

x070.qh - 9.5 - 03/10/27 QEF Home The Guide's Table of Contents Previous Chapter Top Of Page Next Chapter