QEF home page

Appendix E: Q-Tree Command Summaries

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

Tool entries in the x-qef database.


The following descriptions are extracted from the x-qef database.
arupdate	update an archive library
bfsic		build file system integrity check and db maintenance
bp		deliver source code boiler plate
cc_g		gcc interface that eliminates gratuitous warnings
cc_z		cc interface that eliminates gratuitous messages
ccsed		cc interface that applies sed script to assembler file
chstat		change the status of files named in list or arguments
cleanilog	clean up an instal.log file
cmdcmp		compare the outputs of two commands
com		compile or process file using embedded command
condln		link or copy file1 to file2
confvrs		create or compare qvrs config file
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
dirsetup	set up a directory from prototype file
dmpdeps		dump or test deps object
double		output differing lines of files separated by tab
environ		list arguments, user info, open files, $vars, and ignored signals
envset		output environment setting commands
envstd		list arguments, open files and ignored signals
fcmp		compares new and old
fdate		output formated 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
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
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
howto		output selected howto information
incls		dynamic dependency tracker
instal		paranoidly install a file and audit it
instdir		install a directory
instfls		install files, but only if necessary, according to script
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
ldbm		extract from or add to dbm line database
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
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
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
pa		output, list, or delete cut files
pathclash	produce list of duplicated executables in path
pathto		map argument file to special directory
pdirs		directory stack manipulation for shells without pushd
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
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
qefsort		sort or merge text files
qenv		output environment variables in sorted usable form
qfunc		output selected qfunc function/alias file
qgdiff		graphical file difference viewer
qhy		report why a target was rebuilt
qlex		interface to lex
qliceadd	add licences to a licences database
qlicedmp	dump licences database
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)
qsg		the primary qef script generator
qsgcomp		compiles a qsg script to object
qsgdump		dump a qsg object file
qsh		qef shell command interpreter
qtreeinf	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
recur		execute a command repetitively
rep		another grep
rls		recursive list of files
rmlist		remove files named in input
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
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
sls		source path ls
srclist		check the srclist._ file
strfix		replace variables according to replacement dictionary
subdist		create sub-distribution from master file lists
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
tchown		change ownership and mode according to a template
touchfiles	list or create touch files
traits		output traits table
transl		translate input fields
treedirs	mkdir selected or all sub-directories of a qef tree
untouch		set file times
upd		update conventionally named versions of 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		set the write modes for files
wot		output embedded sccs id strings
x-html		html qsg library eXplanatory D.B.
x-ldtree	x_db database describing routines of the -ldtree library
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_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

^^ 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 contains 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 and the .c module that is
		created (i.e., _vmodule.c) is compiled using the
		flags _F_mkvernum_cc[module] or _F_mkvernum_cc.

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

^^ bfsic  build file system integrity check and db maintenance

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

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

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

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

^^ bp  deliver source code boiler plate

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

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

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

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

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

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

^^ cc_g  gcc interface that eliminates gratuitous warnings

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

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

^^ cc_z  cc interface that eliminates gratuitous messages

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

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

^^ ccsed  cc interface that applies sed script to assembler file

	ccsed is an interface to the standard C compiler that applies
	a sed(1) script to the assembler code before it is assembled.
	The ccsed command is the same as the cc command except that one
	of the -E, -S, or -c flags and one and only one *.c file must be
	specified in the argument list.  For the -c option, ccsed invokes the
	appropriate cc command with a -S flag to create the AsSuffix file.
	The resulting file is then processed by sed (using cush to do file
	redirection).  The output file is the normal assembler file (e.g.,
	`file.s') with a prefixing underbar (e.g., `_file.s').  This file is
	then processed by _T_as to produce the ObjSuffix file.

	ccsed is most commonly used to massage assembler files to fix strings
	or external references.

	See also: ccsed(1) ccsed(-x) cc_z AsSuffix CcSed_file

^^ chstat  change the status of files named in list or arguments

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

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

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

^^ cleanilog  clean up an instal.log file

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

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

		cleanilog -Iuvp

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

^^ cmdcmp  compare the outputs of two commands

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

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

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

^^ com  compile or process file using embedded command

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

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

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

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

^^ condln  link or copy file1 to file2

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

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

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

^^ confvrs  create or compare qvrs config file

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

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

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

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

^^ count  produce numbers

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

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

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

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

^^ cpifdif  compare new and old and copy if different

	cpifdif is a very fast implementation of

		cmp -s new old || cp new old

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

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

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

^^ ct  cut input into cut file

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

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

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

^^ cush  could (could not) use shell interface

	cush simply runs the argument command, which should consist of a
	program in the current $PATH and 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).

	See also: cush(1) cush(-x) qremote

^^ depsmap  create file mapping suffixes to mkdeps file

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

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

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

^^ detox  remove toxic waste normally found in dos files

	detox removes any carriage returns before a new line and a
	control-z at the end of its input.  Alternatively it can insert
	the carriage returns and control-z.

	An option is provided to change files in situ.

^^ dirlist  produce list of all directories for input file list

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

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

		dir1
		dir1/dir2

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

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

^^ 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)

^^ 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

^^ double  output differing lines of files separated by tab

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

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

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

^^ environ  list arguments, user info, open files, $vars, and ignored signals

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

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

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

^^ envset  output environment setting commands

	envset is used to extract a named set of environment variables settings
	and unsettings specified in a file (defaults to ~/.qtree/envset and
	<qtree-root>/lib/envset) envset outputs the selected set as a series
	of sh or csh commands to perform the various settings/unsettings.

	envset -x explains the syntax of the envset file and describes
	a convenient alias (or function) Ev as:

		alias Ev 'eval `/usr/qtree/bin/envset -cNQ \!*`'	# in csh
		Ev () {
			eval $(/usr/qtree/bin/envset -NQ $*)
		}

	so that Ev <EnvSet> changes the current shell's environment to that
	specified by the argument.  The fully rooted path and the setting of
	QTREE via the -Q flag (uses directory of program minus /bin) are used so
	that the function will work no matter what the current PATH or QTREE.

	Note:	cush has a -e flag that selects a set for interpretation
		before executing the argument command.

	See also: envset(1) envset(-x) cush qfunc

^^ envstd  list arguments, open files and ignored signals

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

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

^^ fcmp  compares new and old

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

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

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

^^ fdate  output formated 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, where as fdate can be used to output the date for
	an arbitrary time such as the time stamps stored in qmkhist._ files.

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

^^ fexists  output file names that match specified attributes

	fexists is used in the FSIC package qef script to filter 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, has a specified mode, has been modified within
	a specified time, or is empty.

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

^^ ffill  fill in suppressed fields

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

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

		ffill -03

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

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

^^ filelist  maintain a file list and their collective modification time

	filelist maintains the list of files in the argument file flist,
	optionally report gains or losses and setting flist's time stamp
	according to the status of the files it names.

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

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

^^ finclude  output file resolving includes

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

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

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

^^ fixflist  remove non-existent files from a file list

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

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

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

^^ flcomm  comm(1) like but columns put into files

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

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

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

^^ fnd  find a command

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

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

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

^^ fndstr  find a string in a file and output offset

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

	fndstr 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

^^ 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)

^^ g  process go files

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

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

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

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

^^ go  detach a command

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

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

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

^^ goes  view or remove jobs from go message files

	go, josh, and jog append messages to ~/.qtree/goes/<host>/gomsgs
	when ever a job is dispatched and when it ends.  The following are
	examples of such records:

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

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

	goes can be used to:

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

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

	Note:	jog might not be available.

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

^^ gomonitor  display josh halt files as updated and other files

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

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

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

		goes -c -h

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

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

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

^^ 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 | rep -F pattern

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

^^ grpsort  sort groups of lines specified by ranges

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

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

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

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

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

^^ hhmmss  output a banner of the time

	hhmmss clears the screen and outputs a banner of the time as in:

	     #     #######   #   #        #######   #     ###     #####
	    ##     #    #   ###  #    #   #        ###   #   #   #     #
	   # #         #     #   #    #   #         #   #     #  #     #
	     #        #          #    #   ######        #     #   ######
	     #       #       #   #######        #   #   #     #        #
	     #       #      ###       #   #     #  ###   #   #   #     #
	   #####     #       #        #    #####    #     ###     #####

	Note that this representation of the time is legible when using the
	``tiny'' or ``unreadable'' xterm fonts.

	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.

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

^^ 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.

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

^^ incls  dynamic dependency tracker

	incls takes as input a list of files and outputs the implied
	dependencies.  One of its primary purposes are 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.

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

^^ instal  paranoidly 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 trail
	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 root to build
	installations!!

	So why's instal misspelt?  See faq8.

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

^^ instdir  install a directory

	instdir is a link to instal that creates directories.

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

^^ 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

^^ 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.

	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

^^ kdbm  extract from or add to dbm database

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

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

^^ l  list files in columns

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

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

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

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

^^ lash  long argument list shell interface

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

	A command may also use multiple arguments.

	lash is similar to the BSD tool apply.

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

^^ lc  list files by type in columns

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

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

^^ 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

^^ libs  output information on libraries used by the named files

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

		/* LIBS: -ldtree

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

	Try:

		libs -aA -lc

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

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

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

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

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

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

^^ lines  print first N and last M lines

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

		file:000123:contents of line # 123 in file

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

^^ linked  list files with multiple links

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

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

	See also: linked(1)

^^ 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

^^ manprep  prepare manual sections for qef info tool

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

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

^^ mimk  issue updating commands according to a dependency script

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

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

^^ mkalltraits  run mktraits on remote hosts

	Without any flags or host arguments, mkalltraits runs:

		qremote -h <host> mktraits -u

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

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

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

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

^^ mkddt  create ddt declaration

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

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

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

^^ mkdeps  compile deps scanner file

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

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

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

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

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

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

^^ mkopts  create options header file

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

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

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

^^ mkqtree  set up new qef tree

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

		mkqtree -t@TreeType directory subtrees ...

	mkqtree performs the following:

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

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

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

^^ mkquete  produce manual section index

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

		section name <tab> description

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

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

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

^^ mksolib  create shared library externs list

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

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

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

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

^^ mktraits  compile traits files

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

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

	These 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)

^^ mkvernum  create or change version string

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

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

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

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

^^ mnfadd  add a new manifest to manifest database

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

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

^^ mnfchk  check manifest database for syntax and consistency

	mnfchk is part of the manifest package -- see mnfdb.

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

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

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

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

^^ mnfcmp  compare two manifests

	mnfcmp is part of the manifest package -- see mnfdb.

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

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

^^ mnfdb  output manifest database release information

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

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

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

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

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

^^ mnfdel  delete releases from manifest database

	mnfdel is part of the manifest package -- see mnfdb.

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

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

^^ mnfput  output a manifest or manifest database

	mnfput is part of the manifest package -- see mnfdb.

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

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

^^ necho  echo with escape interpretation

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

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

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

^^ numb  produce numbered lines

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

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

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

^^ 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

^^ 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 quickly determining if any of the qef
	tools clash with existing tools in the user's $PATH.

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

^^ pathto  map argument file to special directory

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

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

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

		pathto -d qt

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

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

^^ pdirs  directory stack manipulation for shells without pushd

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

		% eval `qfunc pdirs`

	which defines the following functions:

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

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

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

^^ putifdif  copy input to output file if different

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

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

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

^^ qconfset  add variable setting to the conf.vrs file

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

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

^^ qd  shell alias/function to chdir using selected qdsrv database entry

	To facilitate changing directories within the shell one sets the following
	alias or function:

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

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

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

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

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

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

		qd <qds flags> /sub-dir

	See also: qds qfunc

^^ qdchk  check host's qdsrv database entries

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

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

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

^^ qdid  assign qdsrv ident and/or bind to path

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

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

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

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

^^ qdmgt  general qdsrv management interface

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

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

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

		qdsrv -X

	Note:	To edit the database one must:

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

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

^^ qds  select and print entries from qdsrv database

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

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

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

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

^^ qdsrv  qef project database server

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

	* to change, create, or delete path database entries
	* to reserve, set and retrieve qdsrv identifiers used to anchor a
	  user's session to a particular path
	* to freeze (prohibit changes) or reload the database
	* to retrieve the version and process information of the running
	  server
	* to manage the licences
	* 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 QDSRV_HOST QDSRV_PORT ? qdsrv
		qliceadd qlicedmp

^^ 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

^^ 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) Invoke the back-end as named by _BackEnd_ 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(x-qef) -- introduction to qef
		seminar(x-qmisc) -- An introduction to QEF seminar slide set
		qef-tuts(x-qmisc) -- command line and GUI tutorials

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

^^ qefdirs  qef script generator for multiple directories

	qefdirs is one of the two major script generators of the qef system.
	It processes a simple list of directories and a list of their
	constructions and create 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(x-qefdirs) qefdirs(1) qefdirs(-x)
		qefdirs.qh(x-qef) TreeList(x-qvrs) multidir-qef(x-qefeg)

^^ qefgui  run the qef qui

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

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

^^ qefinfo  run the qef info tool

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

	See also: qefgui

^^ qefpp  the qef macro processor

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

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

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

^^ qefsort  sort or merge text files

	qefsort is equivalent to the normal sort program provided by most
	systems.  However, it is provided to circumvent bugs in some versions.

	qefsort is provided on windows systems as that system does not provide
	sort itself.

	It is provided on systems that use a GNU version of sort to circumvent
	the damaged semantics of the -o flag.

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

^^ qenv  output environment variables in sorted usable form

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

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

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

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

^^ qfunc  output selected qfunc function/alias file

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

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

		qfunc qd

	outputs:

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

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

		eval $(qfunc qd)

	Note that:

		qfunc -c qd

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

	Currently the provided functions are:

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

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

^^ qgdiff  graphical file difference viewer

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

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

^^ 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: mimk qmkhist._

^^ qlex  interface to lex

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

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

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

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

^^ qliceadd  add licences to a licences database

	qliceadd adds new licences to the licence file -- defaults to
	<Q>/data/licences.db. The argument keys are provided by the QEF
	supplier.  To generate this key the supplier must be provided with
	the current database's header record and count, which can be
	retrieved using the command:

		qlicedmp -k file

	or

		qdmgt lickey

	The supplier will combine this key and your requests for licences to
	generate the keys to be used as key arguments to qliceadd.

	These keys, assumedly returned by e-mail, should be specified as
	arguments to qliceadd to add the requested licences to the database.
	Then:

		qdmgt licread

	is run to force qdsrv to reread the licence datbase.

	Alternatively the licences may be added via the server using:

		qliceadd -s keys ...
		qdmgt licadd keys ...

	To check the licences current held by qdsrv, run:

		qdmgt liclist

	See also: qliceadd(1) qliceadd(-x) qlicedmp qdsrv qdmgt

^^ qlicedmp  dump licences database

	qlicedmp outputs information about the argument QEF licence files
	-- defaults to <Q>/data/licences.db.  The standard output will look
	similar to:

		Header: ad2000031, 7 nodes
		System (unlimited):
			linux2
			winnt4
		System:
			sun5
			irix6
		Licences:
			bb0000001
			bb0000002
		Demo licences, expires:
			2000/04/01 (za2000091)

	which shows the database has unlimited licences for Linux2 and WindowNt4
	systems, and two regular and one demo licence (until April 1st)
	for use on Sun5 and Irix6 systems.

	To check the licences current held by qdsrv, run:

		qdmgt liclist

	See also: qlicedmp(1) qlicedmp(-x) qliceadd

^^ 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 used by the Microsoft Visual Studio integrated
	development environment. For details on how to use this command, see
	qmsdev(1)

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

^^ qmsg  send a message or mail to designated users

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

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

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

^^ qremote  run a command on a remote host (if necessary)

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

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

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

		<remote-sh> host <Host-Q-Tree>/bin/cush -Q -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).

	<Host-Q-Tree>: the location of the target hosts's <qtree-root>, as
		named by -q argument, the qdsrv variable <host>.qtree,
		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".

	See also: qremote(1) qremote(-x) BuildHost(x-qvrs) QremoteEnv(x-qvrs)
		Remote-Qefs envset

^^ 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) x-qsg(x-qef) qef
		qsgcomp qsgdump

^^ 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(x-qsg)

^^ qsgdump  dump a qsg object file

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

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

			qsgdump -S hanoi

		will output the source for the hanoi script.

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

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

^^ qsh  qef shell command interpreter

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

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

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

^^ qtreeinf  output information on $QTREE and its directories

	qtreeinf 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.4(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: qtreeinf(1) $QTREE relinfo

^^ quete  list x_db topics and quete.db entries that match patterns

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

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

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

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

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

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

^^ qvrs  process the qvrs files

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

	See qvrs-intro(x-qvrs).

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

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

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

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

^^ qvrsdmp  process qvrs binary file

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

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

^^ qvrsexpr  evaluate and output qvrs expressions

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

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

	qvrsexpr was created for use within the graphical user interface.

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

^^ qyacc  interface to yacc

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

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

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

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

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

^^ r90  reflect lines around diagonal

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

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

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

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

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

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

^^ rc  windows resource compiler

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

	See also: rc(1)

^^ rcslocks  report the RCS locked files in a directory

	rcslocks reads its argument directory -- defaults to RCS -- to find
	and 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)

^^ recur  execute a command repetitively

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

	One past use of recur was:

		recur -T qdsrv

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

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

^^ rep  another grep

	rep is yet another version of grep(1).  rep uses regular expressions
	equivalent to that used 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).

	rep 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.

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

^^ 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.

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

^^ rmlist  remove files named in input

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

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

	qef invokes rmlist to implement the Remove* directives.

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

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

^^ 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 the 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
		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 the tree (e.g., baseline, working, object)
		TreeType[] -- types of the other roots
		VCBranch -- displacement from VCRoot of files for tree
		VCRoot -- root of the version tree (if not LastRoot)
		VCSys -- the version system

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

^^ rotf  select fields of input lines for output

	According to Stephen Lane:

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

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

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

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

^^ rpl  replace, print, or delete named lines

	rpl reads lines of the form:

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

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

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

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

	Many programs, such as rep(1), have a -r flag that generates
	rpl input.

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

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

^^ 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

^^ sdba  output statistics about sdbm database

	sdba outputs information about the blocks of the specified argument
	dbm database.

	The first line is the block size as in:

		Block Size=4k

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

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

	For each empty block, sdba outputs:

		#16: no entries.

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

^^ setbytes  set specified offsets to strings

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

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

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

^^ sfdchk  check strfix dictionaries for valid patterns

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

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

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

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

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

^^ sfsic  source file system integrity check and db maintenance

	sfsic is used to compare the lists of existing source and version
	system files against the FSIC files.fl list.

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

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

^^ shfix  process input file incorporating output of embedded commands

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

	The shfix -X flag describes the input file syntax.

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

^^ 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 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)
		SLScmd(x-qvrs) _F_sls(x-qvrs)

^^ srclist  check the srclist._ file

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

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

	        filelist -fmnuv srclist._

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

	        sls -s | srclist

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

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

^^ strfix  replace variables according to replacement dictionary

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

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

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

^^ 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)

^^ 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 preparing input for suprep.  ffill is almost
		suprep's inverse.

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

^^ sysnm  output symbolic system name or check if it matches arguments

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

	sysnm is equivalent to the command:

		system -n

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

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

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

^^ system  output system name or check if it matches arguments

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

	The default output is the same as 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)

^^ 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 to ensure 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

^^ touchfiles  list or create touch files

	touchfiles is used to list existing _Touch_ files, 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)

^^ 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 such as 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)

^^ transl  translate input fields

	transl reads its input lines and reformats (i.e., translates) them
	according to an argument format and outputs the result.  The format
	allows the selection of fields and arbitrary strings and characters.
	The -p pat flag restricts processing to those lines that match
	the regular expression pat.

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

^^ treedirs  mkdir selected or all sub-directories of a qef tree

	treedirs is used to create a shadow object or working tree.  Normally, it
	creates the directories for the files named in @TreedirsList (defaults to
	treedirs.lst in @TreedirsPath).  If such a file is not found, treedirs
	searches the @RootPath trees for the construction files.

	The -X flag to treedirs gives a complete description of the files it
	processes and creates.

	treedirs is usually the second step when one is modifying or building
	a system, the first being to use rootvrs.

	treedirs -L outputs the list of construction files for the argument
	directory tree.  The construction files are:

		qeffile
		qeffile2
		root.vrs
		tree.vrs
		suppress.vrs
		nobuilds.vrs
		noqfile.vrs

	The generated list can be saved in treedirs.lst (the default file
	read by treedirs).  Alternatively treedirs can walk the directory
	tree itself looking for the files of relevance.

	See also: treedirs(1) treedirs(-x) treedirs.lst rootvrs mkqtree
		TreedirsList(x-qvrs) TreedirsPath(x-qvrs) ExcludeDirs(x-qvrs)
		suppress.vrs nobuilds.vrs noqfile.vrs

^^ 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 a specific date.

	See also: untouch(1) untouch(-x) touch(1)

^^ upd  update conventionally named versions of files

	upd is used to rename files to create a pseudo version system. Given
	a file called eg, the command:

		upd eg

	where files eg-2, eg, eg+1, and eg+3 exist, upd will
	perform the following moves:

		mv eg+3 eg+4
		mv eg+1 eg+2
		mv eg	eg+1
		mv eg-2 eg-1

	If given a filename containing a `.', upd uses `o's (for old) and `n's
	(for new) to create old and new versions of a file as in:

		file.nnc
		file.c
		file.oc
		file.oooc

	go creates an output files called ,.g but performs a upd-like
	renaming such as:

		mv ,.oog ,.ooog
		mv ,.og ,.oog
		mv ,.g ,.og

	See also: upd(1) upd(-x) go

^^ vcc  create, compile, link, and remove version string source file

	vcc is an interface to cc that prepares a version file and then
	invokes the argument cmd, replacing +VFILE+ by the created version
	file.  A typical use is:

		vcc -m mimk cc mimk.o +VFILE+ -ldtree

	vcc creates file _vmimk.c, which contains:

		char version[]={"V@(#)Mimk  6.3 - 95/06/23 03:59:36 - linux"};

	with the appropriate values for the version number and date (see
	mkvernum(1)).  The command `cc ...' is then run, with the `+VFILE+'
	argument replaced by _vmimk.c.  Upon completion, the version file is
	removed (unless the -k flag is specified).

	See also: vcc(1) vcc(-x) mkvernum MkvernumFormat _F_mkvernum_cc(x-qvrs)
		ReportMkvernum Revision RevisionString

^^ vci  version control system interface

	vci is a qsg clone that provides basic version control facilities
	such as checking in or out a file, reporting what files are locked,
	outputting the differences between a current file and its version
	system release, and so on.

	These facilities are provided by two qsg libraries: vci and
	@VCSys (@VCSys is usually set in the root.vrs vile).  The vci
	library provides general utilities, whereas the @VCSys library
	provides the implementations of the various facilities for the
	specific version system.  The facilities provided should be:

		changed  list changed files (see cmdcmp)
		ci  check in argument files
		co  check out argument files
		diff  produce differences between file and its v-file version
		lock  lock the argument files
		new  create a new version administration file (v-file)
		novfiles  list files for which there is no v-file
		rlog  produce history logs for argument files
		tell  tell which files are checked out for edit
		unget  unget or uncheck out argument file, discarding changes
		vdiff  run qgdiff on argument files and their v-files

	See also: vci(1) vci(-x) qsg VCSys(x-qvrs)

^^ vernumcomp  compress the mkvernum database

	The version database created maintained by qdsrv for mkvernum is
	usually <Q>/data/mkvernum.db.  Every time mkvernum, or its alias
	vcc, is invoked a line of the following form:

		module version(count) system host directory user time

	is appended to the database, which will therefore be growing
	monotonically. If left unattended this database can get very big and
	loading it can be time consuming.  However, other than the last record
	for each module, which contains the last count for that module, most
	records are not required, other than for historic and auditing purposes.

	vernumcomp reads input, copying comments and the last record for
	each module in the database to its output.  It also appends its input
	to a savefile if specified.

	The following is a recommended procedure for compressing the database,
	while saving old records for possible future consultation.

		cd `pathto qt/data` # chdir to the qtree data directory
		gunzip mkvernum.odb # uncompress old record file
		qdmgt freeze # freeze the qdsrv until new file created
		vernumcomp -i- -o- -s mkvernum.odb # compress the database
		qdmgt reload # unfreeze the qdsrv
		gzip mkvernum.odb # compress the database

	See also: vernumcomp(1) vernumcomp(-x) mkvernum.db mkvernum qdsrv vcc

^^ wcci  windows c compiler interface

	wcci is a program that provides a rational (i.e. Unix cc-like)
	interface to native compilers on Microsoft Windows systems.
	By default, it is configured to drive Microsoft's compiler and linker
	(CL.EXE and LINK.EXE) but it can also be configured to drive other
	compilers through the Wcci* qvrs variables. See wcci(1) for details
	on how wcci works and how it can be configured.

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

^^ whats  whats 2 + 2

	whats evaluates its argument list or its input lines as
	arithmetic-expressions and outputs the results, possibly in a
	specified base.

	The expression may contain all the C binary, unary, and ?: operators
	that may be used on ints.

	See also: whats(1) whats(-x) arithmetic-expression(x-qmisc)

^^ wmode  set the write modes for 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.

	It provides flags to set or clear write bits with simple flags.
	Furthermore it outputs the current write-bits as a flag so that
	the bits can be restored trivially.

	Note:	wmode used to be called wp but was renamed.

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

^^ wot  output embedded sccs id strings

	wot searches the argument files or the files named by files or
	the standard input if the -f flag specified or the standard input
	(if no arguments or -f) for occurrences of the pattern that the
	SCCS program get substitutes for %Z% (i.e., @(#)) and prints
	out what follows up to the first `"', `>', newline, back-slash,
	or null character.  It also supports a -p flag which specifies that
	wot is to search $PATH for the files to be processed, and a -v flag
	that limits the output to strings beginning with `V@(#)'.

	Note:	mkvernum and vcc embed such strings into their products,
		thus wot may be used to determine the version of the tools
		being run.

	For example, the command:

		wot -vp qef qefgui

	will output the version strings for the $PATH's qef and qefgui.

	See also: wot(1) wot(-x) what(1) mkvernum

^^ x-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_db x_db(-x)

^^ x-ldtree  x_db database describing routines of the -ldtree library

	Companies that use the full Q-Tree set of tools often use the man3db
	system to document subroutines and facilities of libraries.  Tips
	database entries describing the library's components are embedded in
	the C source files as comments.  The man3db program is then used to
	extract those comments and convert them from the TIPs format into a
	variety of products such as man3 sections in troff or frame, lint
	libraries, software inventories and x_db databases.

	x-ldtree and any other Q-Tree program whose name is of the form x-lname
	are x_db databases that describe the library -lname.

	Such databases can be examined using the qef gui by selecting those
	databases using the Databases button in the View pull down menu of
	the Qef Info Tools window.

	x-ldtree may not be available on the current system.

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

^^ 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(1) x_db x_db(-x)

^^ 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-qefdirs) qefdirs

^^ x-qefeg  prototype qef files eXplanatory D.B.

	This x_db database contains a number of prototype qeffile files
	and example qvrs files.

	See also: x-qefeg(1) x-qefeg(x-qefeg) x_db(-x)

^^ x-qefgui  qef graphical user interface eXplanatory D.B.

	x-qefgui is an x_db database 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-qefgui) x-qefgui(1) x_db qefgui qefgui(1)
		x_db(-x)

^^ x-qefpp  qef preprocessor controls and macros eXplanatory D.B.

	This x_db(1) database describes qef preprocessor qefpp, its
	controls and macros.

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

^^ x-qfsic  file system integrity (fsic) package eXplanatory D.B.

	This x_db(1) database describes FSIC (the File System Integrity
	Check) package, its tools, files, procedures, error messages, and
	corrective measures.

	See also: x-qfsic(x-qfsic) x-qfsic(1) x_db(-x) FSIC
		fsic-intro(x-qfsic)

^^ x-qmisc  Q-Tree miscellany eXplanatory D.B.

	x-qmisc is an x_db database 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-qmisc) x_db x_db(-x)

^^ x-qproc  software process procedures eXplanatory D.B.

	x-qproc is an x_db database containing items describing a 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-qproc) x_db x_db(-x)

^^ x-qsg  qsg and its support library eXplanatory D.B.

	This x_db(1) database describes qsg (the Qef Script Generator), its
	tools, input syntax, and the scripts of the standard qsg library.

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

^^ 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: qvrs x-qvrs(1) x-qvrs(x-qvrs) x_db(-x)

^^ 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-ldtree  x_db database describing routines of the -ldtree library
	  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.

	Warning: x-ldtree may not be available.

	See also: x_db(1) x_db(-x) xdbs xdbmk

^^ xdbmk  create an x_db data base

	xdbmk converts a source form x_db database to the binary form.

	Note:	x_db and all its aliases such as x-qef, x-qvrs, and x-qsg
		support a -S flag which will output the source form of the
		selected items, hence:

			x-qef -AS

		will dump the entire source of this database and xdbmk can be
		used to recompile it.

	Note:	xdbmk's -X flag outputs the syntax of the input language.
		To facilitate use, the input syntax is summarized here.

	Input format:

	%{ [key ...]	start of a major item -- keys beginning with `*'
			taken to be group names and duplicates not reported
	%{- [key ...]	start of a minor item
	%}		end of an item
	%A key ...	add addition aliases or keys for the item
	%D description	set the short description for the database
	%i file		include named file
	%%...		line beginning with literal %
	%# comment	comment line - ignored
	%c [key ...]	produce columns of selected keys (default major items)
	%l [key ...]	produce list of selected keys (default major items)
	%S ...		line is maintained in database but never output
			used to embed SID lines in source and binary
	%;		%; embedded in a text body is not output to facilitate
			use of unexpanded SCCS keywords (e.g., %A)
			for literal `%;' use `%%;;'
	%<tag str %;	If outputting for tcl, output str followed by tag;
			common tags are: manref, B (bold), I (italics), btn (button)
	... %?word	treat word (or up to %;) as manref as in word
	... %!word	treat word (or up to %;) as italics as in word
	... %$word	treat word (or up to %;) as bold as in word
	... %*word	treat word (or up to %;) as btn as in word
	... %% ... 	a literal % character

	See also: xdbmk(1) xdbmk(-x) x_db

^^ xdbs  list all or specified x_db databases or all their topics

	xdbs is used primarily by the qef gui to retrieve the names,
	pathnames, and descriptions of all or specified x_db databases.
	It will also produce all the available topics for all or specified
	databases.  A flag is provided to cause the output to be formatted
	as TCL lists to facilitate processing within the gui.

	See also: xdbs(1) xdbs(-x) x_db

^^ xfinterp  process -x flag outputs

	xfinterp reads its standard input which is assumed to be the output
	of Q-Tree programs run with the -x flag.  This input is processed
	to format the input to produce one of the following forms:

		* description lines with troff formatting (-d)
		* description lines (-s)
		* skeleton troff manual page (-m)
		* skeleton eml-form manaul 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)

x070.qh - 8.12 - 00/05/13 QEF Home The Guide's Table of Contents Previous Chapter Top Of Page Next Chapter