QEF home page
Short Descriptions of the QEF Tools

The following descriptions are extracted from the x-qef database.

Technical Documentation, Overviews, Tutorials, and Papers
Software Engineering Definitions
QEF Architecture
A Comparison of QEF and Make
A Cook's Tour of the QEF System
An Introductory Guide to QEF
The QEF Quick Reference Card
The QEF Specialist's Reference Card
Short descriptions of all the QEF tools
QEF Papers, Talks, and Presentations

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

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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%

Top of Page 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

Top of Page 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.

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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._

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

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

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

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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>

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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._

Top of Page 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

Top of Page 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)

Top of Page 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.gts.org and it will be created.

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

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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._

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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_[]

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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

Top of Page 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

Top of Page 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)

Top of Page 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)

Top of Page 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

Top of Page 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)

Technical Documentation, Overviews, Tutorials, and Papers Software Engineering Definitions QEF Architecture A Comparison of QEF and Make A Cook's Tour of the QEF System An Introductory Guide to QEF The QEF Quick Reference Card
The QEF Specialist's Reference Card Short descriptions of all the QEF tools QEF Papers, Talks, and Presentations
toolsdesc.qh - 1.25 - 05/09/23 QEF home page