adjmat produce adjacency matrix
arccentre compute the centre of an arc
artimes set last modification times for files of an archive
arupdate update an archive library
ascii print a table of the ASCII character set
bfsic build file system integrity check and db maintenance
bp deliver source code boiler plate
c% cush link that translates _%_ in command
cancreat check if file can be created
cc_g gcc interface that eliminates gratuitous warnings
cc_z cc interface that eliminates gratuitous messages
cerrs parse input extracting cc errors and warnings
chkfile check all files exist killing argument pid on failure
chstat change the status of files named in list or arguments
cleanilog clean up an instal.log file
clrstr output terminal clear string in readable form
clump convert file:lineno input to ranges
cmdcmp compare the outputs of two commands
com compile or process file using embedded command
commw print input terms not in dictionaries
company output company information
condln link or copy file1 to file2
confvrs create or compare qvrs config file
contax output selected contax database entries
conv convert input characters to readable form
count produce numbers
cpifdif compare new and old and copy if different
ct cut input into cut file
cush could (could not) use shell interface
depsmap create file mapping suffixes to mkdeps file
detox remove toxic waste normally found in dos files
dirlist produce list of all directories for input file list
dirname output directory pathname for files
dirsetup set up a directory from prototype file
divide split files at specified pattern
dmpdeps dump or test deps object
dosmap change Unix paths to DOS paths
double output differing lines of files separated by tab
dry run dhrystone tests
elimso eliminate n/troff inclusions
environ list args, uid/gid, cwd, open files, env, and ignored sigs
envset output environment setting commands
envstd list arguments, open files and ignored signals
fcmp compares new and old
fdate output formatted date string
fexists output file names that match specified attributes
ffill fill in suppressed fields
filelist maintain a file list and their collective modification time
finclude output file resolving includes
finda find and replace Ada variables
findc find and replace C variables
findf find and replace tabbed fields
findw find and replace words
fixflist remove non-existent files from a file list
flcomm comm(1) like but columns put into files
fnd find a command
fndstr find a string in a file and output offset
form text formatter and macro processor
fparens check bracket, brace and double quote balancing in form input
ftest test argument file attributes
g process go files
go detach a command
goes view or remove jobs from go message files
gomonitor display josh halt files as updated and other files
gotstr output names of files that contain argument string
grpsort sort groups of lines specified by ranges
hhmmss output a banner of the time
hoff hell of a lot faster than nroff
howto output selected howto information
incls dynamic dependency tracker
instal meticulously install a file and audit it
instdir install a directory
instfls install files, but only if necessary, according to script
jlines join up selected lines
josh a job shell
kdbm extract from or add to DBM database
l list files in columns
lash long argument list shell interface
lc list files by type in columns
lcmp compare two files
ldbm extract from or add to DBM line database
ledmp display current lefile values
leset set up line editing keyfile
liborder process nm of a library to produce dependency graph
libs output information on libraries used by the named files
lines print first N and last M lines
linked list files with multiple links
lls ls for input files with selected fields output
lninsert replace characters in master by lines from source
lntree create tree of symbolic links to input file list
man3db apply trg script to selected items from man3 TIPs database
manprep prepare manual sections for qef info tool
mimk issue updating commands according to a dependency script
mkalltraits run mktraits on remote hosts
mkddt create ddt declaration
mkdeps compile deps scanner file
mkerrs process error databases to produce other source
mkopts create options header file
mkqtree set up new qef tree
mkquete produce manual section index
mksolib create shared library externs list
mktraits compile traits files
mkvernum create or change version string
mnfadd add a new manifest to manifest database
mnfchk check manifest database for syntax and consistency
mnfcmp compare two manifests
mnfdb output manifest database release information
mnfdel delete releases from manifest database
mnfput output a manifest or manifest database
necho echo with escape interpretation
numb produce numbered lines
olex lexical analyser builder
p4files list perforce files for the current root
p4mnf list p4 files for the current root
pa output, list, or delete cut files
parmsdb output parms database in variety of formats
pathclash produce list of duplicated executables in path
pathto map argument file to special directory
pdirs directory stack manipulation for shells without pushd
ph output phone numbers for selected contax database entries
putifdif copy input to output file if different
qconfset add variable setting to the conf.vrs file
qd shell alias/function to chdir using selected qdsrv database entry
qdchk check host's qdsrv database entries
qdid assign qdsrv ident and/or bind to path
qdmgt general qdsrv management interface
qds select and print entries from qdsrv database
qdsrv qef project database server
qdupd add path to qdsrv database
qed somewhere between a line editor and a command interpreter
qedbufs output qed save file structures
qef the driver
qefdirs qef script generator for multiple directories
qefgui run the qef qui
qefinfo run the qef info tool
qefpp the qef macro processor
qenv output environment variables in sorted usable form
qfunc output selected qfunc function/alias file
qgdiff graphical file difference viewer
qhost qtree host server
qhy report why a target was rebuilt
qlex interface to lex
qmsdev Microsoft Developer's Studio project file generator
qmsg send a message or mail to designated users
qremote run a command on a remote host (if necessary)
qrep another grep
qsg the primary qef script generator
qsgcomp compiles a qsg script to object
qsgdump dump a qsg object file
qsh qef shell command interpreter
qtreeinfo output information on $QTREE and its directories
quete list x_db topics and quete.db entries that match patterns
qvrs process the qvrs files
qvrsdmp process qvrs binary file
qvrsexpr evaluate and output qvrs expressions
qyacc interface to yacc
r90 reflect lines around diagonal
rc windows resource compiler
rcslocks report the RCS locked files in a directory
realdir output real directory name for argument directory
recur execute a command repetitively
rep another grep
resort build new output in order specified by input
revl reverse input lines
rls recursive list of files
rmlist remove files named in input
rmnotnamed remove all files not named by arguments
rmwhite output rpl script to remove redundant white space and newlines
rootvrs create or modify the root.vrs file
rotf select fields of input lines for output
rpl replace, print, or delete named lines
rtabs align fields by inserting padding
samefile check if two paths refer to same file
sdba output statistics about sdbm database
setbytes set specified offsets to strings
sfdchk check strfix dictionaries for valid patterns
sfsic source file system integrity check and db maintenance
shfix process input file incorporating output of embedded commands
shuffle shuffle input lines and output
sls source path ls
snm standardized nm output
srclist check the srclist._ file
strfix replace variables according to replacement dictionary
sttyek set or display saved stty erase and kill chars
subdist create sub-distribution from master file lists
summarize summarize selected fields
sumup output summations of selected input fields
suprep suppress repeated fields
sysnm output symbolic system name or check if it matches arguments
system output system name or check if it matches arguments
tabrpl replace tabs by spaces or vice versa
tchown change ownership and mode according to a template
tdbkeys list TIPs database index keys and/or files
tdbm create TIPs key files
tdbrg apply trg program against selected TIPs DBM database entries
ted TIPs file editor
termfnd check if termcap/terminfo entry exists
termsa list all Ada variables in files
termsc list all C variables in files
termsf list all tabbed fields in files
termsw list all words in files
tf output name of non-existent comma file
tildes convert between symbolic and real character representations
timeout execute a program with a time limit
tlist formated listing of TIPs data base files
tmkprof create new TIPs data base profile
topolsrt topologically sort input
touchfiles list or create touch files
tprof output TIPs profile in various formats
traits output traits table
transl translate input fields
treedirs mkdir selected or all sub-directories of a qef tree
trg template driven TIPs report generator
trgdmp print trg object file
trgmk compile trg script
tscan interactive TIPs data base scanner
tstrhash test strhash hashing
typset interface to typesetter and printing packages
untouch set file times
upd update conventionally named versions of files
upto print selected lines from named files
vcc create, compile, link, and remove version string source file
vci version control system interface
vernumcomp compress the mkvernum database
wcci windows c compiler interface
whats whats 2 + 2
wmode write-protect files
wordidx output input lines followed by lines indicating word count
wot output embedded sccs id strings
x-contax contax use and data bases eXplanatory D.B.
x-eml form eml macros eXplanatory D.B.
x-form form macros and syntax eXplanatory D.B.
x-html html qsg library eXplanatory D.B.
x-ldeps deps library eXplanatory D.B.
x-ldtree x_db database describing routines of the -ldtree library
x-lledit ledit library eXplanatory D.B.
x-lqvrs qvrs library eXplanatory D.B.
x-ltc tc library eXplanatory D.B.
x-ltips tips library eXplanatory D.B.
x-man the -man macro set eXplanatory D.B.
x-qed qed commands and facilities eXplanatory D.B.
x-qef QEF facilities and tools eXplanatory D.B.
x-qefdirs qefdirs eXplanatory D.B.
x-qefeg prototype qef files eXplanatory D.B.
x-qefgui qef graphical user interface eXplanatory D.B.
x-qefpp qef preprocessor controls and macros eXplanatory D.B.
x-qfsic file system integrity (fsic) package eXplanatory D.B.
x-qmisc Q-Tree miscellany eXplanatory D.B.
x-qproc software process procedures eXplanatory D.B.
x-qsg qsg and its support library eXplanatory D.B.
x-qvrs qvrs variables, facilities, and files eXplanatory D.B.
x-ted ted the TIPs editor eXplanatory D.B.
x-trg TIPs trg functions eXplanatory D.B.
x-tscan tscan facilities and commands eXplanatory D.B.
x-xfig xfig qsg library eXplanatory D.B.
x-zr qed function library eXplanatory D.B.
x_db x_db database front end
xdbmk create an x_db data base
xdbs list all or specified x_db databases or all their topics
xfinterp process -x flag outputs
xtty convert stty(1) output to full explanations
younger test if files younger than specified time
zfill zero fill digit string
adjmat produce adjacency matrix
adjmat reads the argument files (defaults to the standard
input) and produces an adjacency matrix of the relation-
ships expressed by the input lines.
Input lines consist of white space separated words, the first of
which is taken as the label. The balance of the line's words
are the nodes to which the label is adjacent.
The output is an adjacency matrix with adjacencies marked with an X.
See adjmat(1) for an example.
See also: adjmat(1) adjmat(-x)
arccentre compute the centre of an arc
arccentre computes the centre point of an arc for use by Arc(x-xfig).
The arguments are three points expressed in xfig(1) units,
and the output is two floats expressing the centre point.
If the points are colinear (i.e., not an arc), arccentre
aborts with a suitable diagnostic output.
See also: arccentre (1) arccentre (-x) Arc(x-xfig)
artimes set last modification times for files of an archive
artimes reads the argument ar(1) file and for each member file, sets
the modification time of the corresponding file to modification time
as stored in the archive.
This is used to create realistic modification times for files that are
extracted from object libraries for versions of make(1) that do not
understand how to process archive libraries.
artimes is unnecessary if ar supports the -o flag.
See also: artimes(1) artimes(-x) ar(1)
arupdate update an archive library
arupdate is used as an interface to ar(1) in library building scripts.
arupdate is used instead of ar as it is an interface is based on a
specification of what should be in the library, from which it
determines what actions to take to bring the library up-to-date.
arupdate's arguments are interpreted to create a list of the
files that are to be part of the archive. The actual arguments may
be files to be included, files that contain the names of files to
be included, or the names of other archives, some or all of whose
elements are to be included.
Given this member list, arupdate checks the archive to determine
the files that need to be removed (i.e., in archive but not the list)
the files that need to be replaced (i.e., existing file's time-stamp
is not equal to that in the archive), and the files to be added
(i.e., in the list but not in the archive).
Note: A file named in the argument generated member list need not
exist, provided it is already in the archive.
arupdate then invokes ar once to delete member files that are no longer
part of the library or will be re-added and a second time to add
in the new or replacement member files.
It will then remove all the files that have been added (other than
those extracted from other archives) unless the -k flag has been
specified.
arupdate also supports an option to add a mkvernum generated
version file to the archive.
Note: If the -V module is specified, the .c module that is created (i.e.,
_vmodule.c) is compiled using the _F_mkvernum_cc[module]
or _F_mkvernum_cc flags.
See also: arupdate(1) arupdate(-x) ar(1) mkvernum _F_mkvernum_cc(x-qvrs)
ascii print a table of the ASCII character set
ascii outputs the table of ASCII characters in a variety of formats,
as in:
|000 nul|001 soh|002 stx|003 etx|004 eot|005 enq|006 ack|007 bel|
...
|170 x |171 y |172 z |173 { |174 | |175 } |176 ~ |177 del|
Options exist to produce the hexadecimal or decimal values, of the
values for selected characters, as in:
% ascii a.9
a 141 097 61 lx
. 056 046 2E p
9 071 057 39 n
See ascii(-x) for list of type keys used for the fifth column of
the above output (e.g., 'l' for lower case, 'p' for punctuation).
See also: ascii(1) ascii(-x)
bfsic build file system integrity check and db maintenance
bfsic is used to compare the lists of existing installed and object
file systems against the FSIC database inst.fl, objs.fl, deviates.fl,
except/<sysnm>.fl, and <Q>/lib/bfsic.cf.
Typically bfsic is used in the fsic(x-qsg) script to create the
,p.errors, ,i.tmps, and ,o.tmps files, which in turn are used
to correct the file systems and database.
Note: The fsic directory is typically in @QefAdm/fsic in the
root directory.
See also: bfsic(1) bfsic(-x) FSIC(x-qfsic) inst.fl(x-qfsic)
objs.fl(x-qfsic) deviates.fl except/<sysnm>.fl <Q>/lib/bfsic.cf
bp deliver source code boiler plate
When bp is invoked with an argument X, it searches for a file called
Bp.dir/X in the directories named by $PATH. If such a file is found
and it begins with the sequence `#BP' followed by a tab, the file
is copied to the standard output, after replacing certain `%%'
sequences with run-time values (e.g., the date or user's name) or
interpretations.
bp is used to retrieve and output prototypes of various files, text
or code segments.
If bp is invoked without arguments, it outputs a list of all the
bp files available.
howto is a link to bp that searches for Howto.dir/X files.
Note: Many of the boiler plates relate to the qef system.
See x-qefeg.
See also: bp(1) bp(-x) howto qfunc new-bp(x-qmisc) New-Bp(x-qefgui)
c% cush link that translates _%_ in command
c% is an alias for cush that assumes the -% flag to
save typing six characters.
For a full description see cush(1).
See also: cush c%(1) c%(-x) cush(1)
cancreat check if file can be created
cancreat checks that the argument file can be created, or
opened for writing (if it already exists).
The exit status is 0 if the requested access is permitted
or possible. Otherwise it is -1.
If -d specified, then check is that files may be created
in the directory file. If file is not specified, -d is
assumed and file defaults to the current directory (i.e., .).
See also: cancreat(1) cancreat(-x) ftest test(1)
cc_g gcc interface that eliminates gratuitous warnings
cc_g is a link to cc_z that eliminates the numerous messages
generated by gcc that are of little or no value or cannot be resolved.
The messages to be eliminated are those matched by regular expressions
associated with cc_g in the file <qtree-root>/lib/cc_z.cf.
See also: cc_z cc_z(1) cc_z(-x)
cc_z cc interface that eliminates gratuitous messages
cc_z and its links are interfaces to the standard C compiler that
filters cc output to eliminate various gratuitous messages such as
the copyright notices and warnings that cannot be resolved. The
file <qtree-root>/lib/cc_z.cf should contain lines that indicate the
real compiler program to be used and regular expressions to be
applied. That file contains comments that describe its contents in
more detail.
See also: cc_g cc_z(1) cc_z(-x) cc_z.cf
cerrs parse input extracting cc errors and warnings
cerrs reads its input, extracts C compiler diagnostic messages,
converts them to a canonical form of file, `:', lineno, `:', and
message, optionally converts file names to canonical forms using a
mapping mechanism, and outputs the result. This allows one to feed
the output of a large qef or make session to cerrs and get a
usable list of the diagnostics.
See also: cerrs(1) cerrs(-x)
chkfile check all files exist killing argument pid on failure
chkfile checks that its argument files exist or are writable (if -w
specified. If any do not exist (or unwritable), it sends a SIGTERM to
the argument pid process and exits with status -1. If the pid
argument is not specified, chkfile just exits with a diagnostic
message and a non-zero status.
If all the argument files exist, chkfile exits silently with status 0.
chkfile is used within shell scripts to abort the script if a check
file is removed as in:
touch CHK$$
echo To terminate this program, remove CHK$$
while true ; do
: commands ...
chkfile -p $$ CHK$$
done
See also: chkfile(1) chkfile(-x) ftest test(1)
chstat change the status of files named in list or arguments
chstat is a combination of chmod(3), chown(3), and chgrp(3) that
processes the files named in argument files or in the standard input.
chstat is useful for processing large numbers of files named by
some pipe line or file.
See also: chstat(1) chstat(-x) tchown wmode chmod(1) chgrp(1) chown(1)
cleanilog clean up an instal.log file
Whenever instal(1) is run, if the qvrs(1) variable @InstLog is set,
instal appends an audit trail record to the @InstLog file (usually
instal.log at the base of the Object tree). This audit file can grow
substantially and may contain many obsolete records. cleanilog may be
used to eliminate obsolete records and optionally remove records
that refer to non-existent files from an instal audit trail.
To update the current tree's @InstLog file, purging references to
non-existent files, use:
cleanilog -Iuvp
See also: cleanilog(1) cleanilog(-x) instal InstLog(x-qvrs)
clrstr output terminal clear string in readable form
clrstr writes (to the standard output) the string of characters that
will clear the screen of the terminal as specified by the term
argument (default $TERM).
By default the string is output in a printable form (e.g., ESC
(octal 033) shown as "\33", newline output as "^J").
The -n suppresses this translation and the -q flag outputs
the string in as a qed string.
See also: clrstr(1) clrstr(-x) qed clear(1)
clump convert file:lineno input to ranges
clump reads its input, which should be a series of lines similar to
that produced by qrep's -n flag (i.e., contain the file name, a
colon, and the line number, a colon, and the contents), as in:
file:14:This is the first line of a clump
file:15:This is the second line.
newfile:200:This is a single line clump
This is also the form of output produced by many other programs such as:
lines, findc (et al), and rpl.
Groups of input lines that refer to a series of sequential lines are
output as "clumps".
Clumps are output as the file name, a colon (':'), the line number
of the first line. If it is a multi-line clump, the line number
is followed by a comma and the number of following lines in the clump.
For the above input, the output would be:
file:000014,1:
newfile:000200:
This output may be input to rpl with the -sa flags to get
the addressed lines.
See also: clump(1) clump(-x) rpl qrep
cmdcmp compare the outputs of two commands
cmdcmp compares the output of a command to the output of another
command, the contents of a file or the standard input. It can also
compare the contents of a file to the contents of another file or the
standard input, although that is just duplicating the capability of
cmp(1) or fcmp.
cmdcmp was created to circumvent the problems of the ambiguity of the
exit status of a pipeline and the problems associated with the
management and removal of temporary files.
See also: cmdcmp(1) cmdcmp(-x) fcmp cmp(1)
com compile or process file using embedded command
com extracts specially identified command lines, called com lines,
from its argument files, processes those lines to replace special
strings by parts of the argument file name or extracted from the
qvrs(1) files, and interprets the resulting line as a shell command.
A com line is a line within the first 1024 characters of the file that
contains the string `/*^' or `/*%'. The balance of the line is
processed to replace `^' characters followed by special strings by
special interpretations (as listed by com -X). The resulting line
is then executed as a sh(1) command.
<qtree-root>/lib/comlines contains the com macros.
See also: com(1) com(-x) qvrs
commw print input terms not in dictionaries
commw reads its input and outputs all terms in the input that are
not in one of the dictionaries.
The input file and dictionaries must be in the order normally
generated by termsw.
A dictionary term is equivalent to an input file term if the
dictionary term is equal to the lower case version of, or the
unpunctuated version of the input file term.
commw typically used to prepare a replacement dictionary for findw
as it understands the punctuation, accents, and capitalization rules
of that program.
Note: commw was originally created to compare words found by
termsw against dictionaries to determine words to be
corrected. Given the availability of fairly good versions
spell(1) one is probably better of using spell to
find terms that are questionable and then use that list
to create the findw replacement dictionary.
See also: commw(1) commw(-x) findw termsw <Q>/lib/words
company output company information
company uses the information specified in the -i specified strfix
dictionary company-info (defaults to ~/.qtree/company.cf or
<Q>/data/company.cf) and outputs that information according
to the format specified by the -f file or format.
The result is written to specified outfile or the standard output.
Note: bp also consults the company info file.
See also: company(1) company(-x) bp <Q>/data/company.cf ~/.qtree/company.cf
condln link or copy file1 to file2
condln, given two argument files f1 and f2, ensures that f1 is
linked or copied to f2, even if f2 already exists. condln is
used instead of ln(1) as that program fails under a number of
conditions that condln avoids (e.g., f2 exists or is on a different
file system).
In summary, condln tries to ensure that file2 is either a link (hard
or symbolic) to file1 or is a link to a copy of file1 or is itself a
copy of file1.
See also: condln(1) condln(-x) ln(1) mklink(x-qsg)
confvrs create or compare qvrs config file
The second file processed by qvrs(1) is the file that the user
provides or names to set configuration parameters. The actual
file used is based on @ConfVrs or searching for conf.vrs or
confdefl.vrs in the directories named by @?ConfVrsPath.
confvrs provides a number of services with respect to the current
config file and the default version. The default behaviour is to
output the name of the current config file and the names and values
for the variables it sets.
Other facilities (selected by flags) show the variables and values
for the default config file (-D), show the differences between the
real and default config files (-d); and copy the default config file
to conf.vrs (-o).
See also: confvrs(1) confvrs(-x) qvrs qconfset mkqtree ConfVrs(x-qvrs)
ConfVrsPath(x-qvrs) conf.vrs(x-qvrs) confvrs/(x-qvrs)
confdefl.vrs(x-qvrs) confdefl-eg(x-qefeg)
contax output selected contax database entries
contax is a TIPs application program that scans the specified contacts
database and outputs selected entries in the selected format.
As such this program can be used for a variety of applications. For
example, it can retrieve and display the phone numbers and/or
addresses for selected names. It can produce form letters in which it
fills in the title, affiliation, address, and salutation for selected
names and/or keywords. Using the keyword search facility it can be
used for distribution lists to drive electronic mailings. contax
selects items from the specified contax data base, and outputs the
selected entries in the specified format.
See also: contax(1) contax(-x) ph x-contax TIPs
conv convert input characters to readable form
conv outputs a line, such as the following, for each character
(excluding the nulls) in the arguments.
Character x : Octal 170 Decimal 120 Hex 78 Binary 01111000
If no arguments are given, stty(2) is used to set the terminal into raw
mode (so as to get all the bits and to suppress any interpretation)
and a single input line is read, up to the first newline, carriage
return or ctrl-d. Then lines of the above form are output for each of
the characters in the read line. The line for the terminating
character is not output, unless it is the only character in the input
or the -e flag is given.
conv's major use is to determine what all those strange keys on a
keyboard actually deliver. It is frequently used when designing a
leset file or a qed terminal file.
See also: conv(1) conv(-x) qed leset
count produce numbers
count outputs the integers from a specified start (defaults to 0)
to a specified stop (defaults to 32767) in using the specified
increment (default 1 or -1 (if the start > stop).
A printf(3) format can be specified for the output.
count was added to the QEF product at a client's request, for
what I know not, but it can be useful.
See also: count(1) count(-x)
cpifdif compare new and old and copy if different
cpifdif is a very fast implementation of
cmp -s new old || cp new old
without the complications that arise due to cmp's exit codes.
It is used extensively to install new versions of a file only
if the file is changed.
See also: cpifdif(1) cpifdif(-x) cmp(1) putifdif cmdcmp
ct cut input into cut file
ct copies its input files or the standard input into a temporary
file in the directory named by $CTDIR or ~/.qtree/ctdir.
The companion program pa can be used to retrieve the saved file
by explicit basename or an age index (0 for the youngest, 1 for
the next youngest, etc.)
See also: ct(1) ct(-x) pa
cush could (could not) use shell interface
cush simply runs the argument command, which should consist of a
program and the arguments to that program. Flags and options allow
command line specification of the setting and unsetting of environment
variables, redirection of I/O, chdirs, special process management, and
process attributes often not available or not easily done using the
standard shells.
One of the more important cush options is to facilitate the saving
of the input in a temporary file, the name of which is inserted into
the argument command. This facilitates using commands that require a
file and cannot process the standard input. cush is also used to
do redirection of I/O in command processors which do not support I/O
redirection, when the redirection cannot be expressed in the current
shell's context (i.e., on a remote machine or as a different user), or
when doing so imposes an additional overhead (e.g., forking a shell).
cush has a -E flag that allows the specification of an envset
environment set to be applied before executing the program. This
option can thus be used to change $PATH or to specify an environment
on a remote host as is done by qremote.
Note: c% is a link to cush that converts any "_%_"s in the
argument command to spaces. It's actually equivalent
to cush invoked with the -% flag.
See also: cush(1) cush(-x) envset qremote c%
depsmap create file mapping suffixes to mkdeps file
depsmap processes the argument files which must be dependency state
tables and description files as produced by mkdeps. The Class name,
Description field, and the Suffixes list for each file are extracted
and saved. Once all the files are processed, depsmap writes the
resulting lists to the output file ofile (defaults to the standard
output).
The resulting file is used by other programs to map a file to the deps
class to be used to process the file. The depsmap output file is
normally installed as <qtree-root>/lib/deps/deps.map.
See also: depsmap(1) depsmap(-x) mkdeps dmpdeps incls deps.map
detox remove toxic waste normally found in dos files
detox removes any carriage returns before a new line and a
control-z at the end of its input. Alternatively it can insert
the carriage returns and control-z.
An option is provided to change files in situ.
dirlist produce list of all directories for input file list
dirlist reads pathnames from its input files and outputs a unique
sorted list of all the directories involved in the input pathnames.
Given the path name dir1/dir2/file, dirlist would output:
dir1
dir1/dir2
dirlist is used to produce the list of directories that may have
to be processed to deal with named or listed files.
See also: dirlist(1) dirlist(-x) dirname(1)
dirname output directory pathname for files
By default, dirname outputs the directory file for each
argument path or, if the -f flag specified, for each file
name contained in the argument file. If no file arguments
are given, the file names read from the standard input are
processed. If any -p, -d, or -l flags are specified, the
selected file name parts (the simplified pathname -p, the
directory name -d, and the leaf name -l) are output in
that order, separated by tabs.
The named files are reduced to their simplest form by
removing redundant parts of the name (e.g., ``/./'',
``/X/../''). the resulting path is then split into the
directory and file name parts.
See also: dirname(1) dirname(-x) basename(1)
dirsetup set up a directory from prototype file
The input files to dirsetup consist of lines specifying directories,
files and their contents, and annotations. When dirsetup processes
such a file, dirsetup creates the specified directories and files in
directory dir. dirsetup will not overwrite any existing file unless
the -o flag is specified. Any annotations are output to the standard
output.
dirsetup files are usually used to define file systems for special
applications such as the qef tutorials or a generic qef administered
project.
In the absence of any arguments or flags, dirsetup lists the currently
available dirsetup files.
Currently the dirsetup databases are:
dotqtree set up for a user's .qtree directory
fsic files of the file system integrity check
miniproj files for a minimal qef project
newproj infrastructure files for a qef project
qeftut1 qef tutorial set # 1
qeftut2 qef tutorial set # 2
qeftut3 qef tutorial set # 3
qegappl example qef application package
qeglibeg example qef library set up and mgt.
qegqsl example of project specific qsglib
See also: dirsetup(1) dirsetup(-x) new-dirsetup(x-qmisc)
dirsetup-sets(x-qefeg)
divide split files at specified pattern
divide reads the argument files (defaults to the standard
input) and splits the output into files named prefix001,
prefix002, ... (prefix defaults to ``x'').
The files are split at the <num>th line if no linemarker
is given. Otherwise, the files are split at the first
line after (if -a specified) or the last line before (if
-b specified) a line that matches the regexp(x-qmisc) pattern
specified by the -p flag.
See also: divide(1) divide(-x) split(1) regexp
dmpdeps dump or test deps object
Dependency files are created by the mkdeps program. They contain a
state table to find and extract embedded dependencies such as the
`#include' of the C programming language plus information used to
convert an embedded `included' symbol to a file.
The dependency suffix map file, deps.map, is used to map file names to
deps files. Basically it contains the names of the supported deps
files and patterns that match the files that it processes.
dmpdeps outputs readable representations of either a selected
dependency file or the dependency suffix map file.
Some useful commands:
dmpdeps -m # show list of current deps files
dmpdeps -cc # dump information about c deps file
dmpdeps -s -c tex # dump source for tex deps file
See also: dmpdeps(1) dmpdeps(-x) mkdeps incls depsmap deps.map
dosmap change Unix paths to DOS paths
dosmap reads its argument files (defaults to the standard input) and
copies what was read to ofile (defaults to the standard output),
converting any strings embedded in ``%%''s to their DOS path names as
mapped by roots.map files.
See also: dosmap(1) dosmap(-x) dospath(x-ldtree) roots.map
double output differing lines of files separated by tab
double reads lines from its two input files in parallel. If the input
lines differ, they are output as a single line with a separating tab.
double is commonly used to produce a replacement dictionary for other
tools such as findf(1).
See also: double(1) double(-x) comm(1)
dry run dhrystone tests
dry runs the dhrystone tests which are an attempt to measure sure
the performance of the host machine. For example:
% dry -l 5hk
Dhrystone(1.1) time for 500000 passes = 4
This machine benchmarks at 125000 dhrystones/second
As might be deduced this is an old program on an old platform.
Upping the number of loops may increase the accuracy.
See also: dry(1) dry(-x)
elimso eliminate n/troff inclusions
elimso is used to eliminate n/troff ".so" commands from
the input by replacing the containing line by the named
file. Also supported is the facility to incorporate the
output of shell commands.
It is provided for use by typset.
Note: The -S option specifies that the qvrs variable @SrcPath
directories are searched for files to be included.
See also: elimso(1) elimso(-x) typset soelim(1) qvrs
environ list args, uid/gid, cwd, open files, env, and ignored sigs
environ outputs the argument list (including the first argument) in an
unambiguous form (using `\ddd' to represent unprintable characters),
lists the file descriptors that are open, the signals that are not
SIG_DFL, the real and effective uids and gids, the umask setting, and
the environment variables. The output is written to /dev/tty to
ensure its visibility.
environ was created to test that programs were setting up the correct
signals, arguments, and files before forking and execing another
program. This is usually done by moving the program of interest (i.e.,
the program that will be exec'ed) to a temporary location, linking or
copying environ to the old program name and running the parent program.
Alternatively one may be able to link environ to the program name
in an earlier directory of the $PATH.
See also: environ(1) environ(-x) envstd
envset output environment setting commands
envset is used to extract a named set of environment variables settings
and unsettings specified in ~/.qtree/envset.cf, <qtree-root>/data/envset.cf,
and <qtree-root>/lib/envset.cf).
envset outputs the selected sets as a series of sh or csh commands
to perform the various settings/unsettings.
envset -x explains the syntax of the envset file.
It is convenient to set an alias or shell function Ev to facilitate
running envset and interpreting its output.
In the csh use:
alias Ev 'eval `<qtree-root>/bin/envset -cNQ \!*`'
In sh or one of its clones, use:
Ev () {
eval $(<qtree-root>/bin/envset -NQ $*)
}
Note: There is a qfunc option Ev which will deliver the
appropriate setting.
So then Ev EnvSet will changes the current shell's environment to that
specified by the argument.
The fully rooted path is used so that $PATH does not need to be set
correctly for Ev to work. The -Q flag will set $QTREE to the
the program's path name minus "/bin/envset" (i.e., <qtree-root>).
Note: qremote executes cush with the flag -E envset, where
envset is usually the value of @QremoteEnv as extracted
from the root.vrs file.
Note: cush, josh, and qsg all have a -E flags that selects an
envset for interpretation before executing the argument command.
QremoteEnv specifies the envset to be loaded on the remote
system, actually done via cush.
See also: envset(1) envset(-x) cush josh qsg qfunc $ENVSETS
qremote QremoteEnv(x-qvrs)
envstd list arguments, open files and ignored signals
envstd is a link to environ. environ lists its arguments, open
files, real and effective uids and gids, its umask setting and its
environment variables. environ writes its output to a file
(usually /dev/tty) opened specifically to ensure its visibility.
When environ is invoked as envstd, the various outputs can be
selected by flags and the output is written to the standard output.
See also: envstd(1) envstd(-x) environ
fcmp compares new and old
fcmp is a link to cpifdif and is equivalent to specifying a -n or -N
to that program. Basically, fcmp compares the files new and old and
exits with status 0 if they are identical, and 1 otherwise.
fcmp is basically the same as cmp(1) except faster, consistent, and
providing some important options.
See also: fcmp(1) fcmp(-x) cpifdif cmp(1)
fdate output formatted date string
fdate formats a specified time -- defaults to the current time --
according to a specified format. The format argument consists of `^'
followed by a single letter to select the element of the time to be
output. For example:
fdate '^a ^h ^d ^T ^c^y'
would output:
Mon Jan 31 05:48:21 2000
The command:
fdate -X
will output the format keys and their descriptions.
fdate predates the extension of date(1)'s extension to provide
similar functionality, however, date is limited to displaying the
current time, whereas fdate can be used to output the date for
an arbitrary time such as the time stamps stored in qmkhist._ files.
See also: fdate(1) fdate(-x) date(1)
fexists output file names that match specified attributes
fexists is used in the FSIC package qef script to filter a list of files
to remove those that aren't empty. This is used in a pipeline with
rmlist to remove the empty files.
fexists can also be used to select input paths that are or are not
files, directories, have a specified mode, have been modified within
a specified time, or are empty.
See also: fexists(1) fexists(-x)
ffill fill in suppressed fields
ffill fills in empty fields with the contents of the most recent
non-empty corresponding field in a previous line. In effect it is the
inverse of suprep.
The fields to be filled in are selected by the `-0..9' argument
(defaults to `-0'). For example:
ffill -03
specifies that the zeroth and third fields are to be filled in. All
other fields are to be copied out directly.
See also: ffill(1) ffill(-x) suprep double
filelist maintain a file list and their collective modification time
filelist maintains the list of files in the argument file flist,
optionally reports gains or losses and sets flist's time stamp
according to the status of the files it names.
srclist is a special case link to filelist that uses the file
called srclist._ and implies the flags -mnuv.
See also: filelist(1) filelist(-x) srclist srclist._
finclude output file resolving includes
finclude copies its input files to its designated output, replacing any
lines that begin with `include' (or a specified string) by a header line,
the contents of the included file, and a trailer line.
finclude is often used to prepare input for other processes, in
particular strfix.
See also: finclude(1) finclude(-x) strfix
finda find and replace Ada variables
finda searches the argument files for ADA variables that
are named in the first field of the argument dictionary file and
replaces those found terms by the replacement field.
finda is almost equivalent to findc and a full description
of the flags and processing is given in findc(1).
termsa will produce a list of all the ADA variables found
in the files given as input.
See also: finda(1) finda(-x) findc(1) termsa findc findf findw
findc find and replace C variables
The four find[cfwa] programs search the argument files (defaults to
the standard input but see -f) for terms given in the argument
dfile (dictionary file). findc searches for C variables; findf
searches for fields; findw searches for words, and finda searches
for ADA variables. When a term is found, if the dictionary file
specifies a replacement string (follows a tab character) the term is
replaced by that string.
The default (in absence of any -cru flags) action is to
copy any lines that contain terms given in the dfile to
the standard output.
The find? programs are particularly useful for creating input
to rpl.
termsc will produce a list of all the C variables found
in the files given as input.
See also: findc(1) findc(-x) termsc finda findf findw rpl
findf find and replace tabbed fields
findf searches the argument files for fields that are named in the
first field of the argument dictionary file and replaces those found
terms by the replacement field.
Fields are tab separated strings.
findf is almost equivalent to findc and a full description
of the flags and processing is given in findc(1).
termsf will produce a list of all the fields found in the files
given as input.
See also: findf(1) findf(-x) termsf finda findc findw
findw find and replace words
findw searches the argument files for words that are named in the
first field of the argument dictionary file and replaces those found
terms by the replacement field.
See termsc(1) for a definition of word.
findw is almost equivalent to findc and a full description
of the flags and processing is given in findc(1).
termsw will produce a list of all the words found in the
files given as input.
See also: findw(1) findw(-x) termsw findc(1) termsc(1) finda findc findf
fixflist remove non-existent files from a file list
fixflist reads in filelist as a list of white space separated
pathnames. Any pathname that does not refer to an existing file is
removed from the list. If the -a flag is specified filelist
itself is added to the list (subject to -a and -r special case).
If the resulting list is empty and the -r flag is specified,
filelist is unlinked. Otherwise the list is sorted and written out to
filelist.
fixflist was created to maintain file lists within the File System
Integrity System (see FSIC). One of the byproducts of that
package is a file list containing all the known temporary files (i.e.,
a.out, core, or any file beginning with a `,').
See also: fixflist(1) fixflist(-x) FSIC
flcomm comm(1) like but columns put into files
flcomm is a comm(1) like program that allows columns to be diverted
to separate files and aborts in case of sequence errors or duplicated
lines. It was created to support the file mechanism used within the
Q-Tree directory file system integrity check (see FSIC) previously
called fl, hence the "fl" prefix.
flcomm is used in FSIC package qef script to compare file lists against
the known file lists and output the differences to specified files.
See also: flcomm(1) flcomm(-x) comm(1) FSIC fsic(x-qsg)
fnd find a command
fnd searches the directories specified by $PATH for the argument
file. If it finds an executable file corresponding to the argument
file fnd writes the full path name to the standard output.
Flags allow the user to specify the inclusion or exclusion of
the current directory, or the reporting of all instances in the
path.
See also: fnd(1) fnd(-x) pathclash which(1) $PATH(x-qvrs)
fndstr find a string in a file and output offset
fndstr searches the argument files -- defaults to the standard input
-- for the argument string, and outputs the offset of that string if
found.
fndstr was provided to facilitate setting the name of the database in
the sysnm binary. See sysnm(1) for a description of how fndstr
and setbytes are used to perform this.
See also: fndstr(-x) fndstr(1) setbytes sysnm
form text formatter and macro processor
form is a general purpose macro processor that is intended to be
used as a front end for troff(1) and other text formatters. form is
generally used in conjunction with a macro package, the analog of
troff macro packages such as -ms or -man. form has several advantages
over straight troff: it has a more readable syntax, better macro
definition facilities, and it can be used to make documents portable
between different text formatters.
It should be noted that all the Q-Tree man pages are written in
form and that typset has a -f flag to invoke form on its
input.
See also: form(1) form(-x) fparens typset x-form (x-form)
x-eml (x-eml)
fparens check bracket, brace and double quote balancing in form input
fparens processes its inputs as specified by arguments searching
for possible problems in form input with respect to:
* unbalanced `{'s, `[', `]', `}', and `"' characters;
* an `@' just before the end-of-file;
* a file that does not end with a newline;
* a nested unescaped special character;
* an unnested unescaped special character (suppressed if -n);
* an `@' immediately followed a character other than one of the
special characters.
Any detected anomalies are reported as rpl format lines (i.e.,
(i.e., filename, colon, line number, colon, comment). For example:
cmd1/man/envset.1:000207: `{' at position 2 unclosed
See also: fparens(1) fparens(-x) form x-form
ftest test argument file attributes
ftest tests the argument file for the attributes specified via the
flags, outputting the appropriate diagnostic and/or taking some other
action.
ftest was created to eliminate the complicated and cumbersome testing
that is sometimes required in shell or make scripts to test whether or
not a file can be changed or exists.
See also: ftest(1) ftest(-x) test(1) cancreat
g process go files
g is used to view and optionally remove the diagnostic output files
of go and josh, referred to as the go-files.
Within the qef gui, go is used to detach builds creating the files
displayed by the build monitor. g can be used to view those files.
Note: The -d flags to go and josh cause the output files to be
created in the user's ~/.qtree/goes/<host> directory. The
-d flag to g causes it to look in the appropriate directory.
See also: g(1) g(-x) go josh goes gomonitor $GODIR
go detach a command
go executes its argument command in background, usually redirecting
the standard input and outputs, possibly sending a message when the
argument command has completed. go is used to detach builds within
the qef gui, redirecting the outputs to diagnostic files that can be
viewed using the build monitor.
go appends messages to ~/.qtree/goes/<host>/gomsgs when a command is
executed and when it terminates. goes can be used to remove
lines for completed jobs from the ~/.qtree/goes/<host>/gomsgs files.
See also: go(1) go(-x) g goes ~/.qtree/goes/<host>
$GODIR(x-qvrs) $GOFILE(x-qvrs)
goes view or remove jobs from go message files
go, josh, and jog append messages to ~/.qtree/goes/<host>/gomsgs
whenever a job is dispatched and when it ends. The following are
examples of such records:
pid command ~ host - directory yyyy/mm/dd hh:mm:ss
pid:status command ~ host - directory yyyy/mm/dd hh:mm:ss
pid! command ~ host - directory yyyy/mm/dd hh:mm:ss
pid:status! command ~ host - directory yyyy/mm/dd hh:mm:ss
The `:status' fields indicate that the job has completed, the `!'
that the job has been canceled. For completed jobs, the command
and directory fields may be truncated so that the entire line
fits into 80 characters.
goes can be used to:
+ view job records for current, specified, or all hosts;
+ cancel job records (i.e., insert a `!' after the pid:status field)
for completed jobs or jobs over a day old [*];
+ remove job records for completed or day old jobs [*].
[*] Can be applied to the current host's (default), a specified host's,
or all hosts' gomsgs files.
Note: jog might not be available.
See also: goes(1) goes(-x) go josh gomonitor jog(1)
~/.qtree/goes/<host>/gomsgs
gomonitor display josh halt files as updated and other files
gomonitor monitors the ~/.qtree/goes/<host>/gomsgs files, displaying
job records that are appended to those files by go and josh.
Lines for completed lines are displayed in reverse video.
gomonitor also outputs the date and time (updated every five seconds),
the number of messages in your mailbox, the contents of ~/.qtree/goshow
(if non-empty) or the contents of ~/.qtree/td (see td(1)) and the
diary entries for the next week (see diary(1)).
gomonitor is designed to be run continuously in an xterm window,
refreshing the date and time every five seconds and the other
contents when they are changed. The command:
goes -c -h
may be used to cancel completed commands, for all hosts, which will
suppress their display by gomonitor.
An alternative to gomonitor is provided by the Build-Monitor window
of the qefgui. It provides facilities for viewing the go files
as they are created, removing selected go-files, halting or rerunning
jobs, and many more facilities.
Note: td(1) and diary(1) may not be part of your system.
See also: gomonitor(1) gomonitor(-x) josh g goes Build-Monitor(x-qefgui)
gotstr output names of files that contain argument string
gotstr outputs the list of files named in filelist arguments (defaults
to the standard input) that contain the argument string, and it does so
very quickly by using a Boyer/Moore algorithm and reading 32K at a time.
Frequently gotstr is used to prepare an argument list for grep(1) as in:
grep pattern `gotstr string filelist`
or better:
gotstr string filelist | qrep -F pattern
See also: gotstr(1) gotstr(-x) qrep bm(1)
grpsort sort groups of lines specified by ranges
grpsort reads its input files, searching for lines that match the
specified argument regular expression. The matched line and the lines
that follow up to (but not including) the next matched line constitute
a group. All lines are copied to a temporary file and the matched
string and the offset to its group are saved. Once all the input has
been read, the matched strings are sorted. Then the groups are read
from the saved input in the sorted order and output.
Note: If the pattern contains a sub-pattern -- specified by `\(...\)'
the string matched by the sub-pattern is used as the sort key.
As an example of its uses, grpsort is used to sort x_db entries, each
of which begins with `%{' optionally followed by a `-' and white
space. Thus to sort the entries of an x_db database by the first
key of a line one uses:
grpsort '^%{<-|>[ ]*\(.*\)'
See also: grpsort(1) grpsort(-x)
hhmmss output a banner of the time
hhmmss clears the screen and outputs a banner of the time as in:
# ####### # # ####### # ### #####
## # # ### # # # ### # # # #
# # # # # # # # # # # #
# # # # ###### # # ######
# # # ####### # # # # #
# # ### # # # ### # # # #
##### # # # ##### # ### #####
Note that this representation of the time is legible when using the
``tiny'' or ``unreadable'' xterm fonts.
An alternative representation is provided that uses highlighting
which is somewhat more attractive.
By default, the display is refreshed every ten seconds on the ten
second time. An interrupt (usually Ctrl-C) will cause the time to
be refreshed every second and a subsequent interrupt will revert to
refreshing on the ten second mark.
To terminate the clock use two interrupts within a second.
An option (-S) is provided which shows a count down or elapsed
time, which when combined with the highlighting representation
is very useful for showing students the time left for an exam.
See also: hhmmss(1) hhmmss(-x) xclock(1)
hoff hell of a lot faster than nroff
hoff is a much cut down (might I say absurdly cut down) version of
nroff(1) to be used to format simple documents or quickly left
justify and fill lines.
For example, hoff was used to justify and fill these lines
just by piping them through hoff within the editor (qed)
using:
?much cut?,. | hoff
A list of the supported commands can be found in hoff(-x).
See also: hoff(1) hoff(-x)
howto output selected howto information
When howto is invoked with an argument X, it searches for a file called
Howto.dir/X in the directories named by $PATH. If such a file is found
and it begins with the sequence `#HT' followed by a tab, the file
is copied to the standard output, after replacing certain `%'
sequences with run-time values (e.g., the date or user's name) or
interpretations.
howto is used to describe various procedures and/or standards.
If howto is invoked without arguments, it outputs a list of all the
howto files available.
howto is a link to bp.
There are a number of howto files provided by default:
dirsetup How to edit a dirsetup database
help How to help someone use a computer
howto How to create a new howto file
swhygiene Stenning's Project Hygiene Principles and Suggestions
The author finds it a convenient mechanism for storing and accessing
miscellaneous information.
See also: howto(1) howto(-x) bp
incls dynamic dependency tracker
incls takes as input a list of files and outputs the implied
dependencies. Its primary purpose is to maintain the incls._
database and to produce the dependency list used within the qef
scripts.
incls uses finite state automatas stored in files produced by
mkdeps to the argument files.
The qvrs variable SrcProdMap[class] may be used to extend the
list of affixes and their dependencies as generated by the -M
and -m flags.
incls will consult and update a universal cache of dependencies
in a DBM database named by @InclsDbm. Using such a database
saves rescanning commonly used headers such as stdio.h.
See incls.dir and InclsDbm.
See also: incls(1) incls(-x) mkdeps incls._ dmpdeps depsmap
SrcProdMap incls.dir InclsDbm InclsDbmUpdate
instal meticulously install a file and audit it
instal [sic] is used to install files in remote directories. instal
accepts flags from the qvrs variables @_F_instal and @_F_instal[root] as
well as on the command line. It maintains an audit trail in the path
named by qvrs variable @InstLog. instal works hard to check that
everything happened correctly.
Of particular importance is the -I flag which causes instal to not
fail if it cannot set the specified mode, owner and/or group. In such
an instance, instal outputs a noisy warning message and records the
failure in file named by appending `.fix' to @InstLog (after removing
`.log' if it exists). The failure is recorded in the format read by
tchown which can be used by a privileged user at the end of the
build. This feature means that one does not need to be the root user
to build installations!!
So why's instal misspelt? See faq8.
See also: instal(1) instal(-x) _F_instal(x-qvrs) InstLog(x-qvrs) tchown
instdir install a directory
instdir is a link to instal that creates directories.
See also: instdir(1) instdir(-x) instal instdir(x-qsg)
instfls install files, but only if necessary, according to script
instfls reads its input script which contains a number of
source/destination path name pairs. It installs the source files into
the destination files, but only after checking to ensure that the
installation will result in a significant change. A history file is
maintained to suppress file comparisons if the files have not changed
since the last time instfls was run.
instfls can also take a list of files and the names of the source and
destination directories.
See also: instfls(1) instfls(-x) instfls(x-qsg) instal
if_install._ih if_install._il
jlines join up selected lines
jlines copies the named file(s) (defaults to the standard input) to
the standard output, replacing selected newlines (i.e., joining some
lines) by specified string.
Normally, newlines escaped by a concatenation character (default `\')
are removed (together with the escape concatenation character). By
default, the concatenation character is assumed to precede the newline
but one can choose to have the escape character appear after the
newline to be removed (i.e., at the beginning of the next line).
See also: jlines(1) jlines(-x)
josh a job shell
josh is a command interpreter that manages jobs selected by name
from the specified josh file -- defaults to ~/.qtree/josh.
A josh file consists of lines of the following form:
# comments say no more
X=value assign a value to variable X
group ~ pats ... specifies that `group' implies jobs
matched by specified patterns.
labels...: commands the jobs to be done; commands may
be continued over multiple lines
and incorporate variable values
and command line arguments.
josh selects jobs to be done by those labels or groups matched by
command line specified patterns. The associated commands are then
interpreted using the shell. Flags are provided to detach the job
redirecting the output as is done by go, in which case josh
maintains a josh halt file that records progress and can be used
to halt a josh job.
An extremely important task performed by josh is to facilitate remote
executions of qef jobs as described in Remote-Qefs.
See also: josh(1) josh(-x) gomonitor go g Remote-Qefs
$GODIR(x-qvrs) $GOFILE(x-qvrs)
kdbm extract from or add to DBM database
kdbm is a tool used to create, update and query a DBM database.
Basically a kdbm database uses ASCII keys with single or multiple
text line data elements.
See also: kdbm(1) kdbm(-x) ldbm sdba
l list files in columns
l is yet another ls(1) type program that lists entries in the
specified directories. It is provided as part of the Q-Tree
to ensure a consistent interface and provide additional
capabilities not normally available using ls.
lc is a link to l that implies the -a and -l flags -- list all files
(-a) by file-type (-l).
Note: Some man(1) commands cannot retrieve l(1) due to their
interpretation of `l' as being a section number. In
such a case see lc(1).
See also: l(1) l(-x) lc lc(1)
lash long argument list shell interface
lash runs its argument command repetitively for the specified
arguments -- possibly read from the standard input. The command
should contain % character sequences to specify the positions and
forms of the arguments. Supported forms include selecting the
argument's directory, basename, root, etc.
A command may also use multiple arguments.
lash is similar to the BSD tool apply.
See also: lash(1) lash(-x)
lc list files by type in columns
lc is a link to l that lists the files in the argument directory
by type (e.g., directories, devices, etc). It also lists all
files whereas l suppresses files whose names begin with a `.'.
See also: lc(1) lc(-x) l
lcmp compare two files
lcmp compares the two argument files byte by byte and reports any
differences as the octal address (see -d flag) of the difference and
the symbolic representation of the characters in each file separated
by tabs, as in:
000117 \t ` '
000120 007 x
000340 EOF \n
In most respects, lcmp is equivalent to cmp(1) with the -l flag.
The differences are the use of the symbolic representation of the
characters, use of octal addresses, and treatment of the EOF.
See also: lcmp(1) lcmp(-x) cmp(1) fcmp
ldbm extract from or add to DBM line database
ldbm is used to create, update and query an ldbm database. which
is a DBM database (i.e., X.{dir,pag} pair) in which a key's data
item (as stored in the X.pag file) is a list of seek offsets into
third file X.data. The offsets point to newline terminated lines
of text for the key.
See also: ldbm(1) ldbm(-x) kdbm sdba
ledmp display current lefile values
ledmp outputs the tables size, termcap strings and key mappings
contained in the argument leditor control file (default $LEFILE,
$LEDIR/${TERM} or <qtree-root>/lib/ledir/${TERM}). Flags may
be used to select one or more of the output tables.
See keys(x-lledit) for a list of the leditor keys.
See also: ledmp(1) ledmp(-x) leset (x-lledit) leditor $LEFILE
leset set up line editing keyfile
leset creates and writes to object (defaults to the standard
output) the setup file needed for the leditor control file used in
qed and other tools. Normally this file is stored as
<qtree-root>/lib/ledir/${TERM}. However, the user may specify an
explicit lefile by setting the $LEFILE shell environment variable or
may specify a directory to be searched before looking in the standard
position by setting $LEDIR.
The input file syntax is described briefly in leset(-x) and fully
in leset(1).
The special keys symbols and their semantics are listed by the -k flag.
See also: leset(1) leset(-x) leditor ledmp
liborder process nm of a library to produce dependency graph
liborder reads a snm output for a library and produces a dependency
graph of the library's modules. This output is usually input to
topolsrt (or tsort(1)) to produce a topologically sorted list of
the library's modules.
liborder used to be required on some old platforms to create the
ordered list of modules, however, this has been rendered unnecessary
by ranlib(1) or ar(1) features.
See also: liborder(1) liborder(-x) snm topolsrt
libs output information on libraries used by the named files
libs processes a list of symbolic library names given via arguments,
or the libraries specified for an argument file via the LIBS[]
variable or as embedded in the files themselves as in:
/* LIBS: -ldtree
By default, libs outputs the library names or symbols that will be
used when linking the named file or library. Flags may be specified
to show the raw library list (-r), the list after LibMap expansion
is done (-m), the expanded list after the library search is done (-e)
the list of symbols to be used when linking (-c), and list all
libraries that match a specified symbol (-A).
Try:
libs -aA -lc
Note: If a libs argument begins with [name], as in:
libs [alternative]/.../realfilename.c
then alternative is used to match LibStatic[] patterns, instead
of realfilename.
Note: The qvrs -l flag outputs a list of all the variables used
in library searches and their current settings.
See also: libs(1) libs(-x) *lib-macros(x-qefpp) *lib-vars(x-qvrs)
Apropos: ? -Q <Lib|archive|libs>
lines print first N and last M lines
lines prints the first head (default 5) and the last tail
(default 0) lines of each argument file (defaults to the standard
input) or the files named by the files or the standard input if the
-f flag is specified. lines also supports a -r flag which
causes lines to output lines in the rpl format, for example:
file:000123:contents of line # 123 in file
See also: lines(1) lines(-x) rpl
linked list files with multiple links
linked checks the argument files (defaults to files named in the
standard input) or the files named by the argument files (if -f)
for files that exist and have multiple links. If there are 1 or less
links nothing is output, otherwise the name of the file is output.
A flag (-s) is provided that output those files that are symbolic
links.
See also: linked(1) linked(-x)
lls ls for input files with selected fields output
lls is yet another variant of ls(1), with the difference that
the files to be listed may be named by the standard input or the
argument files and the file attribute fields displayed are
selectable by a command line option (see -o).
The list of selectable fields is output by lls(-x) and given in lls(1).
See also: lls(1) lls(-x) rls
lninsert replace characters in master by lines from source
lninsert reads the master file and searches it for the replacement
character (defaults to '%'). Each replacement character is replaced,
in the output stream, by characters from the source file, up to the
next newline not preceded by a backslash. The newline is included in
the output unless the -n option is specified. The resulting merged
stream is written to the standard output. Either one of the master or
source files may be assigned to the standard input by using a `-'
instead of a file name.
lninsert is yet another useful tool for merging lists of fields into
a master form, possibly repeating the master, to create form letters
or database entries.
F.Y.I.: lninsert is ancient, dating back to fourth edition UNIX.
See also: lninsert(1) lninsert(-x)
lntree create tree of symbolic links to input file list
lntree reads a list of pathnames from the argument file (defaults to
the standard input) and creates a ``shadow'' tree in the current
directory that consists of symbolic links to the input pathnames
relative to the argument fromroot. Hard links are used if symbolic
links are not supported by the host system. Directories are created
as required.
Pathnames in the argument files or the standard input are separated by
white-space or newlines. Strings following a `#' at the beginning of
a line or after a space or tab are ignored.
If the n flag is specified, lntree does nothing other than to report
what it would do.
See also: lntree(1) lntree(-x) ln(1) link(2) symlink(2)
man3db apply trg script to selected items from man3 TIPs database
man3db is a special purpose TIPs trg program that will apply the
built-in trg program format or the trg source file trg as specified by
the -b or -t arguments to the items in the specified files or the
``*.d'' files in the argument dir (default ``*.d''). If a -q flag is
given, only those items that match the argument Tips query are
processed.
man3db is used to produce the x_db libraries such as x-ldtree.
man3db entries describing the routines of the library are embedded
in the actual source. man3db extracts these entries and processes
them with a built in man3db format that produces x_db formatted
information (possible being processed through form and grpsort).
See also: man3db(1) man3db(-x) man3db(x-qsg)
manprep prepare manual sections for qef info tool
manprep is used to transform output of man(1) into the form required
for presentation by the qef graphical user interface. The output
consists of Tcl/Tk expressions specifying bold text, section headers,
and references to other manual sections.
See also: manprep(1) manprep(-x)
mimk issue updating commands according to a dependency script
Yet another make(1), but built specifically to be a suitable back-end
for qef. mimk duplicates most of the important functionality of make,
but does not support variables or suffix rules, as such things are done
in other qef processes. mimk will run processes in parallel and will
rerun constructions if the dependency list or the constructions itself
has been changed since its last execution.
See also: mimk(1) mimk(-x) qhy qmkhist._
mkalltraits run mktraits on remote hosts
Without any flags or host arguments, mkalltraits runs:
qremote -h <host> mktraits -u
for all hosts <host> for which the variable <host>.qtree exists in the
qdsrv database. The mktraits will rebuild the <Q>/data/traits/<host>.tab.
This is usually necessary after <Q>/lib/traits.vrs or <Q>/data/traits.ext
files are changed and the traits binary files stored in traits/<host>.tab
files need to be rebuilt.
The -r flag specifies that rsh(1) is to be used instead of qremote as
might be required when qremote cannot be run due to a missing traits
file.
See also: mkalltraits(1) mkalltraits(-x) traits qremote qdsrv
mkddt create ddt declaration
mkddt transforms its argument input files into a C header or source
file (if -c) containing appropriate initializations for Ddt_t
structures used to control the Dynamic debugging trace (ddt) package.
mkddt is used to build qef itself and a number of other Q-Tree
packages. It is not intended for general use at this time. As such
it might not be available.
See also: mkddt(1) mkddt(-x)
mkdeps compile deps scanner file
mkdeps compiles a description and control variables of the scanner
used to process files to extract embedded dependencies such as the
`#include' statements of C.
The resulting object file is used by various programs (e.g., incls)
to extract embedded dependencies from a source file. Such files are
usually stored in <qtree-root>/lib/deps.
dmpdeps may be used to examine and/or test a mkdeps object or an
installed version.
depsmap is used to create a file that maps from file suffixes to
mkdeps object files.
Warning: The mkdeps language is obtuse and baroque. It is not
intended for the casual user. If you need a new language
supported, write to support@qef.gts.org and it will be created.
See also: mkdeps(1) mkdeps(-x) incls dmpdeps depsmap mkdeps(x-qsg)
mkerrs process error databases to produce other source
mkerrs processes a library's error database to create required header
files. The user provides a TIPs error database.
mkerrs is used to convert entries in these files to the two C language
header files required to use the error handling package.
mkerrs is used to build the Q-Tree product itself so is provided
as part of that product.
See also: mkerrs(1) mkerrs(-x) mkerrs(x-qsg) TIPs
mkopts create options header file
mkopts creates a C language header file of defines for options. It is
used to create header files based on qvrs option settings.
A qsg library script (mkopts(x-qsg) exists to create header files
using mkopts.
See also: mkopts(1) mkopts(-x) mkopts(x-qsg)
mkqtree set up new qef tree
mkqtree creates a new qef shadow tree for the current directory.
Given the command:
mkqtree -t@TreeType directory subtrees ...
mkqtree performs the following:
mkdir directory # if directory does not exist
cd directory
rootvrs -tTreeType original-directory # if no root.vrs
confvrs -c # if conf.vrs does not exist
treedirs subtrees ... # if subtrees not .
The above creates the new directory, creates the root.vrs file linking
the new directory to the original, copies confvrs/confdefl.vrs to
conf.vrs and populates the tree with the requested sub-directories.
See also: mkqtree(1) mkqtree(-x) rootvrs confvrs treedirs confdefl.vrs
mkquete produce manual section index
mkquete processes manual sections to extract the short description
in the NAME section and to build output records in the following form:
section name <tab> description
Flags or the traits variables ManSections and ManZipSuffixes name the
manual sections to be processed and the suffixes for compressed
files respectively.
mkquete is run to produce <qtree-root>/data/quete/*.db which is read by
quete to create a manual section topic list within the help information
window in qefgui. See QueteDbs(x-qefgui).
See also: mkquete(1) mkquete(-x) man(1) traits data/quete quete.db-maint
mksolib create shared library externs list
mksolib is used to convert a list of variables and their types into
a C module which can then be linked with a library to create a
shared object (i.e., so) library.
Basically to create a shared library, a mksolib input file is created
that lists at least one variable from every required module in the
archive. When such a file is processed by mksolib, and then compiled
and linked with the standard object library (with the appropriate
flags), a shared library containing the defining modules for each
of the listed variables is created.
A qsg library script (mksolib(x-qsg)) exists to facilitate mksolib's use.
See also: mksolib(1) mksolib(-x) mksolib(x-qsg)
mktraits compile traits files
mktraits creates the traits database <Q>/data/traits/<host>.tab.
The traits database is a set of variable/value pairs used to store
system, host, and site settings such as capabilities, pathnames, and
special values such as QDSRV_HOST.
mktraits compiles the traits source files traits.vrs and traits.ext.
The language used in these files is identical to that of qvrs, except
that the trait(x-qvrs) function is not supported.
Note: Whenever mktraits -Ru is run, any traits/<host>.tab file
that is older than either of the source files is removed.
Running traits or any query of the traits database via the
libdtree.a A.P.I. will recreate the file if necessary.
See also: mktraits(1) mktraits(-x) traits trait(x-qvrs) trait(x-qsg)
traits-vars traits/<host>.tab
mkvernum create or change version string
mkvernum extracts the current module version number from the qvrs
variable Revision[module] or Revision and generates a version string
for embedding in the code or library. Many of the qsg scripts
support a -v flag that will automatically create, compile and add
the version string to a program or library.
One of the important mkvernum features is its ability to embed the
value of a counter that is incremented on each use in the output
string. These counters are retrieved by communicating to qdsrv
which maintains <Q>/data/mkvernum.db.
Note: vcc is a link to mkvernum used to create and compile a
C version file.
See also: mkvernum(1) mkvernum(-x) vcc qdsrv vernumcomp verlib/
<Q>/data/mkvernum.db Revision(x-qvrs) _F_mkvernum_cc(x-qvrs)
ReportMkvernum MkvernumFormat MkvernumPath RevisionString
mnfadd add a new manifest to manifest database
mnfadd is part of the manifest package -- see mnfdb. mnfadd adds a
new input manifest to a manifest database and outputs the result.
See also: mnfadd(1) mnfadd(-x) mnfdb manifest(x-qmisc)
mnfchk check manifest database for syntax and consistency
mnfchk is part of the manifest package -- see mnfdb.
mnfchk reads the argument manifest database -- defaults to the
standard input -- outputting any syntax errors in the manifest
database to an argument file -- defaults to the standard output. If
the -S flag is specified, for all files/version tuples in the selected
releases (defaults to all), mnfchk finds the associated s-file and
checks that the named version actually exists.
See mnfchk(1) for a list and explanation of the errors that can
be output.
Note: The -S check works with SCCS files only. To check a manifest
for some other system, use mnfput -m to retrieve the files
and associated versions and input that information to a mechanism
that checks the validity of the file/version tuples.
See also: mnfchk(1) mnfchk(-x) mnfdb manifest(x-qmisc)
mnfcmp compare two manifests
mnfcmp is part of the manifest package -- see mnfdb.
mnfcmp compares two manifests reporting the differences in three tab
separated fields, giving the file name, the file's version numbers in
the first and the second manifests. If a file is not listed in either
one or the other manifests the associated version field is output as a
single caret (`^').
See also: mnfcmp(1) mnfcmp(-x) mnfdb manifest(x-qmisc)
mnfdb output manifest database release information
mnfdb outputs the release information for the releases selected by
the -r flags (defaults to -r \*) in the named manifest database.
mnfdb is part of the manifest package which consists of the following
tools:
mnfadd add a new manifest to manifest database
mnfchk check manifest database for syntax and consistency
mnfcmp compare two manifests
mnfdb output manifest database release information
mnfdel delete releases from manifest database
mnfput output a manifest or manifest database
See mandb(1) for descriptions of manifests, manifest databases,
releases, and the care and feeding of manifest databases.
See also: mnfdb(1) mnfdb(-x) manifest(x-qmisc)
mnfdel delete releases from manifest database
mnfdel is part of the manifest package -- see mnfdb.
mnfdel is used to remove a named release or releases from a manifest
database. The associated release declarations are removed as are all
bindings of file/version tuples to those releases. The resulting
manifest data is output to a named file or the standard output.
See also: mnfdel(1) mnfdel(-x) mnfdb manifest(x-qmisc)
mnfput output a manifest or manifest database
mnfput is part of the manifest package -- see mnfdb.
mnfput reads the selected manifest database and outputs the named
releases. The -m flag outputs a resolved manifest. If multiple
releases are selected and those releases specify differing versions
for a specific file, the version specified by the youngest selected
release is output.
See also: mnfput(1) mnfput(-x) mnfdb manifest(x-qmisc)
necho echo with escape interpretation
necho just echos its arguments, much the same as echo(1).
However, necho provides special character interpretation in its
arguments to facilitate specification of non-printable characters,
such as "\r", "^M", or "\15" for carriage return.
necho also provides output redirection via arguments, which may
be necessary to ensure correct interpretation or alternatively
eliminate the need to invoke a shell.
See also: necho(1) necho(-x) echo(1)
numb produce numbered lines
numb reads lines from the argument files (defaults to the standard
input) and outputs the line with a line number.
An option (-f) exists to allow the specification of the output format.
See also: numb(1) numb(-x)
olex lexical analyser builder
olex is the original lex(1) provided to circumvent the limitations
of flex(1). It is required to boot the Q-Tree as the lex sources
all use feature in control the I/O that cannot be emulated within flex.
Note: DO NOT USE!!
See also: olex(1) olex(-x) qlex(1) _T_lex lex(1)
p4files list perforce files for the current root
p4files is used to produce a list of the files in the perforce files
in the appropriate branch.
Basically p4files builds a p4 command to list the files in the depot.
The most basic command is "p4 -sync -n".a
The command's output is read by p4files to extract the file name, the
type, and the revision number. The output will consist of the
filename, relative to the current directory, the optional affix, the
type in parentheses, and the revision number (if the -M flag was
specified).
This input will typically be sent to sfsic to compare the perforce
depot's files against the FSIC file lists.
See also: p4files(1) p4files(-x) p4mnf perforce(1) p4(1) sfsic sfsic.cf
p4mnf list p4 files for the current root
p4mnf is used to produce a file manifest in the perforce(1) files
in the appropriate branch.
Basically p4mnf builds a p4(1) command to list the files in the
depot. The most basic command is "p4 files".
The command is modified to add additional flags -- e.g., -x-, d
depot.
The constructed command is executed, possibly with the argument files
or files specified by those files (if -F flag specified) input to
the command as the standard input.
The command's output is read by p4mnf to extract the file name and
the revision number which are output with a separating tab.
This input will typically be with the mnfdb package to maintain a
release database.
Note: m4mnf is very similar to p4files.
See also: p4mnf(1) p4mnf(-x) p4files perforce(1) p4(1) mnfdb
pa output, list, or delete cut files
pa and its companion tool ct paste and cut files. When ct is
invoked it copies its input into a file in the user's $CTDIR
(default ~/.qtree/ctdir) directory. The name of the new file is
`,' followed by two decimal digits.
pa can be used to list, examine, retrieve and/or remove cut
files by relative age or explicit index.
The default command is to cat the most recently modified file
in the $CTDIR directory.
See also: pa(1) pa(-x) ct $CTDIR ~/.qtree/ctdir
parmsdb output parms database in variety of formats
parmsdb processes the specified parms database -- defaults to
<qtree-root>lib/parms -- for items that match the specified query
(default all) and outputs those items in the selected format --
defaults to ``default''.
The parms database describes the parameters used to configure the
Q-Tree for the system. The parameter files are parmsdb dictionaries
normally stored in the magic/parms directory of the Q-Tree source.
Typically a parameter assigns a string value that will be used to
configure header and data files during the boot strap.
Unfortunately, the database tends to slip out-of-date.
See also: parmsdb(1) parmsdb(-x)
pathclash produce list of duplicated executables in path
pathclash outputs the file names that occur in more than one of the
directories named by $PATH -- in other words, the path name clashes.
It is provided to facilitate quick determination of whether or not any
of the qef tools clash with existing tools in the user's $PATH.
See also: pathclash(1) pathclash(-x)
pathto map argument file to special directory
pathto maps its argument files by replacing symbolic prefixes
to real pathnames. The symbolic names are listed by the -l flag.
pathto is used in shell scripts to facilitate specification of
Q-Tree (and other) files by applying the appropriate substitution
and search mechanisms.
pathto may be used to determine the default <qtree-root> using:
pathto -d qt
Note: Additional symbolic mappings can be specified in the
roots.map files.
See also: pathto(1) pathto(-x) QTREE <qtree-root> roots.map
pdirs directory stack manipulation for shells without pushd
pdirs is provided for use on systems that lack that very useful function
pushd. pdirs should not be used directly as its purpose is to
deliver an argument for a chdir and to maintain a list of directories
which must be done using built-in shell functions. To use pdirs,
one should use:
% eval `qfunc pdirs`
which defines the following functions:
pd () { eval `pdirs -e $* ++ $_dirs` ; }
pushd () { eval `pdirs -e $* ++ $_dirs` ; }
popd () { eval `pdirs -ep $* ++ $_dirs` ; }
dirs () { echo `pwd` $_dirs ; }
The resulting functions pushd, popd, and dirs provide much the
same functionality as their csh name-sakes.
See also: pdirs(1) pdirs(-x) sh(1)
ph output phone numbers for selected contax database entries
ph is a link to contax. The only difference is that invoking
contax using ph automatically assumes the -b ph option. That
option selects the ``ph'' output format which outputs the phone
numbers for the selected entries. For example, the command:
% ph tilbrook
would yield:
David Tilbrook: (+1 416) 925-8168 (office)
(+1 416) ...-.... (mobile)
Frank Tilbrook: (+1 416) ...
See also: ph(1) ph(-x) contax
putifdif copy input to output file if different
putifdif compares its standard input to contents of its argument file,
copying the input to the argument file if they differ.
putifdif is used to process configured header files, changing the
installed copy only if its contents would change.
See also: putifdif(1) putifdif(-x) cpifdif
qconfset add variable setting to the conf.vrs file
qconfset is provided to insert or replace a variable setting or an
option at the beginning of the current tree's conf.vrs file, if there
is one. The conf.vrs is the qvrs file used to specify the user's
options and controls. It is typically initialized using confvrs which
copies the default configuration file confvrs/confdefl.vrs.
See also: qconfset(1) qconfset(-x)
qd shell alias/function to chdir using selected qdsrv database entry
To facilitate changing directories within the shell one sets the following
alias or function:
alias qd 'set qdtmp=`qds -d \!*` && cd $qdtmp' # in csh
qd () {
qdtmp=$(qds -d $*) && cd $qdtmp
} # in sh, ksh or bash
The above are also output by the qds -X flag and qfunc qd. To define
qd one uses:
eval `qfunc -c qd` # in csh
eval `qfunc qd` # otherwise
Once set, one can use qd to chdir to trees or sub-directories within
a tree using queries, absolute indices, or qds flags such as -n
or -i.
Note that an argument to qd may be used to specify the sub-directory
of the target tree. If the target tree is the same project as the current
tree, the qd will chdir to the same sub-directory of the target tree.
To specify the root of the tree, on should begin the argument with a
slash as in:
qd <qds flags> /sub-dir
See also: qds qfunc
qdchk check host's qdsrv database entries
qdchk retrieves all the paths for the current host from the qdsrv
database -- see qdsrv(1). For each retrieved path entry, qdchk
checks the fields and directories for validity reporting any
discrepancies.
The error and warning messages produced by qdchk are explained in
individual items of x-qmisc. See *qdchk(x-qmisc).
See also: qdchk(1) qdchk(-x) qdsrv qdsrv-record *qdchk(x-qmisc)
qdid assign qdsrv ident and/or bind to path
qdid provides support for retrieving an unused qdsrv identifier and/or
binding a qdsrv identifier to a qdsrv database entry.
Once an identifier is bound to a path, qds -i may be used to retrieve
that path. Thus a user may identify a path that represents the current
set of working directories.
The environment variable $QDSRV_ID may be used to contain the identifier.
If QDSRV_ID is not set the lowest identifier is assigned to the user.
Note: qds also has an option to do the path binding.
See also: qdid(1) qdid(-x) qdsrv qds $QDSRV_ID
qdmgt general qdsrv management interface
qdmgt provides a generalized message interface to qdsrv. It sends
argument message (possible specified by a flag) to the server and then
just writes the returned messages to the standard error output (if the
returned message begins with a `!') or to the standard output.
qdmgt was developed initially to test the server prior to the
existence of the specialized tools. As such all the qdsrv services
may be invoked via qdmgt and some are available only by using it.
The list of messages supported by qdsrv is produced by the command:
qdsrv -X
Note: To edit the database one must:
qdmgt -v # check that server running and get db name
qdmgt -f # freeze the database
edit <dbfile>
qdmgt -r # reread the database and unfreeze it
See also: qdmgt(1) qdmgt(-x) qdsrv qds qdchk
qds select and print entries from qdsrv database
qds retrieves paths from the qdsrv database. Flags can specify attributes
(e.g., project, release, host) of the paths to be retrieved.
The primary purpose of qds is to provide the argument to a chdir command.
The -d flag specifies that a single path must be selected. If a single
path is matched, the matching paths are output.
qds is used in the qd function or alias to facilitate chdiring
using queries or path indices.
See also: qds(1) qds(-x) qd qdsrv qdmgt qfunc
qdsrv qef project database server
The qdsrv database, usually contained in <qtree-root>/data/qdsrv.db
contains information about qef administered trees. qdsrv is a
server program that provides facilities:
* to change, create, or delete path database entries
* to reserve, set and retrieve qdsrv identifiers used to anchor a
user's session to a particular path
* to freeze (prohibit changes) or reload the database
* to retrieve the version and process information of the running
server
* to halt the server
* to retrieve the time on the server's host
qdsrv should be run on a host on the local network. The host on
which it runs and its port number are named by the traits QDSRV_HOST
and QDSRV_PORT -- see traits(1).
Note: The uid of the qdsrv process must be the owner of the
database. Thus the qdsrv executable should be setuid
to the owner of the database.
See also: qdsrv(1) qdsrv(-x) qdsrv.db qdsrv.log mkvernum.db qds
qdmgt qdid qdchk traits qhost QDSRV_HOST QDSRV_PORT
qdsrv-setup rc.d/qdsrv(x-qefeg)
Apropos: ? qdsrv
qdupd add path to qdsrv database
qdupd is used to add or change a path and its corresponding parameters
to the qdsrv database (usually stored in <qtree-root>/data/qdsrv.db).
See qdsrv(1) for a description of the fields of the database and their
use.
Note: rootvrs invokes qdupd to add or correct paths when a new
root.vrs file is created or changed.
See also: qdupd(1) qdupd(-x) qdsrv rootvrs qdsrv.db
qed somewhere between a line editor and a command interpreter
qed is a multiple-file programmable text editor and a programming
language based on ed(1), intended for use primarily by programmers.
For the average user, qed's power will likely be unnecessary, even
troublesome, and its use is discouraged. For a "knowledgeable" user
who is willing to learn how to use it properly, however, qed is a
powerful tool, both when used as an editor or as a (rather
idiosyncratic and low-level) programming language.
However, it is the only editor the author uses.
There is an ancient (1980) tutorial on qed use in the <Q>/doc
written by Rob Pike and David Tilbrook.
Some interesting features:
- use of leditor to provide cursor editing and key mapping
- rich set of functions -- see (x-zr)
See also: qed(1) qed(-x) qedbufs x-qed x-zr
qedbufs output qed save file structures
qedbufs examines the contents of a qed ``save'' file, as created
by the qed S (for ``save'') command.
The S command writes the contents of all buffers into a file called
X._qa where X is supplied as part of the S command (default
``q''). It also dumps all the buffer controls (i.e., the zero, dot &
dollar) and the register contents into a file called X._qb.
qedbufs outputs some or all of the contents of the X._qb file,
where X is the argument prefix (default ``q'').
See also: qedbufs(1) qedbufs(-x) qed R(x-qed) S(x-qed)
qef the driver
qef is the user interface and driver for the system. Consists of three
major phases:
1) Configuration
2) Script preparation
3) Script Interpretation
1) The first phase consists of initialization and various validity
checks (see ForbidQef), output of the header line, etc., but the
most important aspect is to run qvrs to compile the qvrs-files
into a database that is saved in /tmp/qv_*.tmp for consultation
by qef and other tools.
2) Every directory in which qef is to be run must have an associated
qeffile (or a qeffile2), which is found by searching the @SrcPath
directories or as named by QefFile[@RealBranch]. This file must
contain a Begin line. This line plus other qvrs settings are used to
determine how the back-end input script is to be prepared. Usually this
is one of the following:
* run qefdirs to convert qeffile to a script which is processed
by qefpp to produce a mimk(1) file that handles constructions
across multiple directories; or
* run sls to produce a list (srclist._) of the source files
for the current directory and then invoke qsg to transform that
list and the contents of the qeffile into qefpp input which
will produce input to the back-end.
Other variations are possible, but the above two represent over 95%
of qeffiles.
3) The back-end, as named by _BackEnd_, is invoked to interpret the script
prepared or selected by the second stage. In most instances the
backend will be one of mimk, qsh, or make. Once the back-end
has completed, qef performs a number of clean-ups (e.g., removing
its temporary files), outputs the trailer line and exits.
The manual section qef(1) gives a more complete description of the
processing. Also see the few hundred other sections in this database,
the user guide, and other documentation.
For an introduction, the tutorials, and the introductory seminar, see:
qef-intro -- introduction to qef
seminar(x-qmisc) -- An introduction to QEF seminar slide set
qef-tuts(x-qmisc) -- command line and GUI tutorials
See also: qef(1) qef(-x) qvrs qsg qefdirs
qefdirs qef script generator for multiple directories
qefdirs is one of the two major script generators of the qef system.
It processes a simple list of directories and a list of their
constructions and creates a qef/mimk script that provides facilities to
invoke constructions by group (e.g., Local, Install, Man), or by
individual directories (e.g., cmd~I, man~M).
It also supports division of the directory list into different levels
that can be invoked individually or in ranges.
Note: The input syntax is described by qefdirs's -X flag.
See also: qefdirs-intro (x-qefdirs) qefdirs(1) qefdirs(-x)
qefdirs.qh TreeList(x-qvrs) multidir-qef(x-qefeg)
qefgui run the qef qui
qefgui is a Tcl/Tk application that provides facilities to: navigate
project trees; invoke qef and other tools; access the qef documentation
(such as this); interface with the versioning system, create, delete
and modify files; and create, delete and modify project trees.
See also: qefgui(1) qefgui(-x) x-qefgui qefgui-intro
qefinfo run the qef info tool
qefinfo is just the qefgui program, but limited to the Qef-Info-Tool
window. It is provided for use on systems for which qefgui is not
provided.
See also: qefgui
qefpp the qef macro processor
qefpp is not a separate program. Rather it is a subroutine of qef
itself which preprocesses scripts much like cpp in the C compiler.
Even though qefpp is not a tool, as an important phase of the qef
process it is given an external identity, an albeit brief entry
in this tool database, and its own x_db database x-qefpp.
See also: qefpp(x-qefpp) (x-qefpp)
qenv output environment variables in sorted usable form
qenv without any arguments, outputs the entire list of
environment variables as a series of `=' statements.
Alternatively the -c flag can be used to specify that the csh
format is to be used.
If arguments are specified, they should name environment variables
to be output.
Note: qenv duplicates some of the functionality of the AT&T env
and the BSD printenv, but qenv is consistent and
provides the ability to select individual variables.
See also: qenv(1) qenv(-x) env(1) printenv(1)
qfunc output selected qfunc function/alias file
qfunc is yet another bp link. When invoked with an argument X,
qfunc searches for a file called Qfunc.dir/X in the directories
named by $PATH. If found and the first four characters of the file
are `#QF' followed by a tab, the file is copied to the standard output
after replacing certain `%.' sequences by special run-time values.
qfunc was implemented to facilitate the setting of useful csh and sh
aliases or functions. For example, the command:
qfunc qd
outputs:
qd () {
qdtmp=$(qds -d $*) && cd $qdtmp
} # in sh, ksh or bash
which is the definition of a shell function `qd' which facilitates
chdiring to directories retrieved from the qdsrv using the qds
interface. To perform the definition within the current shell one
would use:
eval $(qfunc qd)
Note that:
qfunc -c qd
delivers the equivalent alias for csh. If qfunc is invoked without
arguments, it outputs a list of the available qfunc files and their
brief descriptions.
Currently the provided functions are:
Ev function to invoke envset for selected set
Qf function to eval qfunc for selected function
cats function to invoke cat on file(s) found using sls
eds function to invoke $EDITOR on file(s) found using sls
pdirs pushd and popd implemented with pdirs
qd function to chdir using qds selection
qdp function to pushd using qds selection
qdpush function to pushd using qds selection
See also: qfunc(1) qfunc(-x) bp howto
qgdiff graphical file difference viewer
qgdiff presents the differences between two argument files -- as
determined by diff -- graphically. The two files are displayed
side by side showing the changes, deletions and insertions
in coloured segments.
See also: qgdiff(1) qgdiff(-x) diff(1)
qhost qtree host server
qhost is a server used by qremote to retrieve the target host's
@System[Name] value, the host's $QTREE, and the user's home
directory on that host.
It should be started at boot time using something similar to
rc.d/qhost.
To start qhost, run:
qhost -S
or
qhost -R # if address still in use
qhost can be used as a client as in:
qhost -v host # retrieve version info of running server
qhost -q host # cause host to quit
qhost -u user host # retrieve home directory for user
# and $QTREE on named host
The normal qhost output for the -u flag or as default is:
host: @System[Name] <qtree-path> <login-dir>
Note: The <login-dir> is $Home[] for the user if defined.
Otherwise getpwnam(3) is used to retrieve the passwd
information for the user.
See also: qhost(-x) qhost(1) qremote qdsrv qhost-setup rc.d/qhost
qhy report why a target was rebuilt
qhy examines the mimk history file qmkhist._ and outputs selected
information concerning the argument files, such as the time and
the reason it was last re-built. A flag (-r) specifies that qhy
is to recurse through files that forced the rebuild. Another flag
(-d) will list all the files on which a file depended and give
their current times.
Note: qhy reports only that information available in the qmkhist._
file or by examining the file system to retrieve current
times for relevant files. The information it reports, such
as the dependency list may have since been changed.
See also: qhy(1) qhy(-x) mimk qmkhist._
qlex interface to lex
qlex is an interface to lex that moves lex.tab.c to appropriate
location and optionally converts `yy' variables.
The qlex flags for file.l are specified by the qvrs variable
_F_lex[file.l] (see _F_*).
The actual program to be run is specified by _T_lex(x-qvrs).
See also: qlex(1) qlex(-x) qyacc
qmsdev Microsoft Developer's Studio project file generator
qmsdev process the qvrs files to produce the proj.dsp, proj.dsw,
and a command file runqef.bat.
These files are required by the Microsoft Visual Studio integrated
development environment. For details on how to use this command, see
qmsdev(1)
See also: qmsdev(1) qmsdev(-x)
qmsg send a message or mail to designated users
qmsg sends a single line message specified by either arguments or
read from the standard input to the specified users. The message
is sent to the user's terminals (if they are logged in) or as mail.
A flag (-m) is provided to force mail to be sent.
qmsg is provided as part of the Q-Tree product as it is used by go to
report that a job has completed.
See also: qmsg(1) qmsg(-x) go josh
qremote run a command on a remote host (if necessary)
qremote is used to run commands remotely, if necessary. Basically
qremote creates and executes a shell command that executes the argument
command on the appropriate host after the necessary setup (e.g., the
setting of $QTREE and $PATH. If the command is to be run locally,
qremote will execute:
<Host-Q-Tree>/bin/cush -Q -E env-set \
-d dir [ go -d ] command ...
If the command is to be run remotely, qremote will execute:
<remote-sh> host <Host-Q-Tree>/bin/cush -Q \
-sHOME=<home> \
-E env-set -r dir [ go -d ] command ...
<remote-sh> will be ~/.qtree/qremote/<host>, <Q>/data/qremote/<host>,
or rsh(1), rcmd(1), or remsh(1) (whichever is provided).
<home>: The user's home directory on the target host retrieved
from qhost server. This is required as Windows does not
set $HOME properly in some cases.
<Host-Q-Tree>: the location of the target hosts's <qtree-root>, as
named by -q argument, retrieved from qhost, or /usr/qtree.
-E env-set: The named envset should set $PATH, $QTREE and
other necessary environment variables. The envset can
be specified via qremote's -E flag or @QremoteEnv.
The default is "qremote".
Distributed Processing Support:
qremote supports a -Sservice option which is used to distribute
processing over selected hosts. If the -Sservice option is specified,
qremote retrieves the value of @_Servers_[service] which should
name the hosts that provide the specified service.
qremote uses the qhost server that should be running on the named
hosts to check that the target hosts are running and to retrieve the
default <qtree-root> and the user's home directory.
qremote then sends a "cycle" message to qdsrv to select the least
recently used host (according to previous "cycle" messages).
The hostname returned by qdsrv is then used as the target host.
See also: qremote(1) qremote(-x) BuildHost(x-qvrs) QremoteEnv(x-qvrs)
Remote-Qefs envset cush qhost qdsrv _Servers_[]
qrep another grep
qrep is yet another version of grep(1). qrep uses regular expressions
equivalent to that used by many Q-Tree tools such as qsg and qvrs.
This version of regular expressions offers a number of features
not offered by other implementations -- see regexp(x-qmisc).
qrep also supports a number of features not offered by other greps
such as multiple patterns and the specification of the files to
be processed via the standard input or the argument files.
Note: qrep used to be called rep.
See also: qrep(1) qrep(-x) rep rpl grep(1) regexp(x-qmisc)
qsg the primary qef script generator
qsg is the primary qef script generator -- see qsg-intro(x-qsg). Its
major purpose is to convert simple statements of intent into the
input to the specified backend. Extensive documentation of the
syntax, semantics and available qsg script may be accessed using x-qsg.
Note: The default input to qsg is the contents of the directory's
qeffile following the Begin line.
See also: qsg-intro qsg(1) qsg(-x) x-qsg (x-qsg) qef qsgcomp qsgdump
vci qmsdev
qsgcomp compiles a qsg script to object
qsgcomp compiles a qsg script to a p-code representation. qsgcomp
is usually used only to create qsg object files for inclusion in
a qsg library such as the default library std.qsl.
See also: qsgcomp(1) qsgcomp(-x) qsg qsgdump std.qsl(x-qsg) (x-qsg)
qsgdump dump a qsg object file
qsgdump is a debugging and documentation aid for the qsg script
programmer and user. Options exist to dump a qsg script's object
code, summary, strings, header, or source.
Note: The standard library std.qsl is searched for the argument
files before checking for a file, hence:
qsgdump -S hanoi
will output the source for the hanoi script.
Also note that qsgdump will compile its argument files if they
are not qsg object files.
See also: qsgdump(1) qsgdump(-x)
qsh qef shell command interpreter
qsh is yet another shell command interpreter specifically provided to
execute shell scripts generated by qef script interpreters such as
qsg. For some directories, such as the file system integrity check
directory, qsh will serve as the backend interpreter instead of make,
mimk, or qmk.
qsh is used instead of sh as qsh provides a better echo facility, can
be made to ignore the exit status of selected commands, and checks
the $QEFHALTFILE file to determine if the qef session is being halted.
See also: qsh(1) qsh(-x)
qtreeinfo output information on $QTREE and its directories
qtreeinfo outputs something similar to the following:
$QTREE: /p/qtree/8.3/linux2_0i
Default $QTREE: /usr/qtree
0: /p/qtree/8.3/linux2_0i
Real Dir: /p/qtree/8.3/linux2_0i
Qtree(full) 8.5(567) - Linux-2.0.34-i686(linux2_0i) - 2000/04/14
dt on gobo in /p/qtree/linux2_0i/o8.3
The first line is the current value of $QTREE.
The second line is the default value for $QTREE.
This is in turn followed by a set of lines for each directory named
by $QTREE. This consists of the directory index, the name used,
the real name of the directory, and the relinfo file contained
in that directory.
See also: qtreeinfo(1) qtreeinfo(-x) $QTREE relinfo
quete list x_db topics and quete.db entries that match patterns
quete is a specialized search tool that searches the title lines
of all the x_db databases it can find (such as this one) and the
quete/*.db database (as built using mkquete) and outputs the
matched lines. One of the flags it supports is -t which causes
the output to be done as a Tcl/Tk list for direct loading into the
Topic window of the qefgui Info Tool window. The output includes
Tcl/Tk tags to allow direct loading of a listed topic by clicking
on the manual or x_db reference.
The Apropos button in the Info Tool window invokes quete. For
example try: ? manual.
quete supports the following flags that may be useful in queries:
-Q limit search to $QTREE manual sections
-X limit search to x_db databases
-M limit search to manual sections
-N Do Not do dual case pattern matching
-<num> limit output to <num> items
pattern ... patterns matched against lines -- Note if a
pattern contains ` & ', it is split into
multiple patterns.
Note: quete is a french noun for quest, search, collection,
and beating about.
See also: quete(1) quete(-x) x_db mkquete quete/*.db
Qef-Info-Tool(x-qefgui)
qvrs process the qvrs files
qvrs is the major parameterization system of the qef system. Due to
its importance there is a x_db database dedicated to its description.
See qvrs-intro(x-qvrs).
qvrs is invoked by many of the qef tools to retrieve settings and
controls. It finds and processes the root.vrs, tree.vrs, qeffile
and leaf.vrs files for the current directory. The -p option writes
out a `compiled' list of all the settings.
To avoid repetitive execution of qvrs within a single qef run, qef
executes qvrs -p saving the output in a temporary file, the name of
which is assigned to the environment variable $QVRS_FILE. Any
program that needs qvrs settings checks this variable first, and if
set, reads the named file directly. Otherwise, the tool invokes qvrs
-p and reads the output from the connecting pipe.
In the absence of any arguments or flags, qvrs outputs the current
settings.
See also: qvrs-intro(x-qvrs) qvrs(1) qvrs(-x) qef x-qvrs (x-qvrs)
qvrsdmp process qvrs binary file
qvrsdmp processes the output produced by qvrs when the -p flag is
specified. The file is read and the symbol table is written to the
standard output. The file to be processed is named explicitly by
argument, by $QVRS_FILE or by actually executing qvrs -p.
See also: qvrsdmp(1) qvrsdmp(-x) qvrs
qvrsexpr evaluate and output qvrs expressions
qvrsdmp evaluates its argument expressions as qvrs expressions and
outputs the results, one line per argument.
This is equivalent to running qvrs with the same arguments, except
that if a -f qvfile parameter is specified or if $QVRS_FILE is
specified, the named file is taken to be the name of the qvrs binary
file as produced by qvrs. By directly loading the database from a
file, the file system searches and the interpretation of those files
done by qvrs -- which can be expensive -- are avoided.
qvrsexpr was created for use within the graphical user interface.
See also: qvrsexpr(1) qvrsexpr(-x) qvrs qvrsdmp qvrsexpr(x-qsg)
qyacc interface to yacc
qyacc is an interface to yacc(1) that moves y.tab.c to appropriate
location and optionally converts `yy' variables.
qyacc was created to make processing yacc files a single command.
The qyacc flags for file.y are specified by the qvrs variable
_F_qyacc[file.y].
The actual program to be run is specified by _T_yacc(x-qvrs).
See also: qyacc(1) qyacc(-x) qlex _F_qyacc(x-qvrs) yacc(1)
r90 reflect lines around diagonal
r90 reads the argument files (defaults to the standard input) and
outputs the result of reflecting the lines around the main diagonal.
This has the effect that the first output line consists of the first
characters of the input lines, the second output line consists of the
2nd character of each input line, and so on. Blanks are used where a
character is missing (i.e., the line corresponding to the position is
shorter than the maximum length line).
Flags are provided to: trim leading spaces and tabs on input (-l);
trim trailing spaces and tabs on input (-t); reverse input lines
after padding to same length (-r); pad output lines to the same
length (-p); trim trailing spaces on output (-T); and reverse
output lines (-R).
r90 has a number of interesting applications which are not easy with
the standard tools, such as:
r90 -pt | r90 # right pad to same length
r90 -rlpt | r90 -R # left pad to same length
r90 -ptR | r90 -T # reverse order of lines in file
r90 -rptl | r90 -R | r90 # create column headings
(r90 -p f1; echo; r90 -p f2) | r90 -T # join files together
The -X flag lists the above as well as how to use r90 to perform the
eight rotations and reflections that can be performed on an input file.
See also: r90(1) r90(-x)
rc windows resource compiler
rc is a shell script provided by Interix that compiles windows
resource files. Further documentation may be available in the
//C/Interix/man.
See also: rc(1)
rcslocks report the RCS locked files in a directory
rcslocks reads its argument directory -- defaults to RCS -- to find
any files of the form *,v. Any such files are read to detect any
locks. If any locks are found the name of the base file (i.e., the
file minus `RCS/' and the any `,v') is output. A -l flag exists to
specify that the locks themselves are to be listed.
See also: rcslocks(1) rcslocks(-x) co(1)
realdir output real directory name for argument directory
realdir outputs the rooted and unambiguous pathname for the argument
directory.
realdir determines the real name for a directory by performing a
chdir(2) to directory (if necessary) and then invoking getwd(3) to
retrieve the true name.
realdir is most often used to retrieve an unambiguous name for a
directory that does not depend on symbolic or conditional links, the
current universe, or special characters such as ~. It is also used to
avoid the inaccuracies that sometimes occur in the setting of $cwd
or $PWD.
See also: realdir(1) realdir(-x) pwd(1)
recur execute a command repetitively
recur executes its argument command repetitively, sleeping num
(defaults to 3) seconds after each execution. If the -i iterations
was specified, recur terminates once the command has been executed
that many times. recur will also exit if -T (while true) flag was
specified and the command returned a non-zero exit status (i.e., false),
or if the -F (while false) flag was specified and the command returned
a zero exit status (i.e., true). Otherwise execution continues until
the program is interrupted.
One past use of recur was:
recur -T qdsrv
that is, run qdsrv repetitively until it successfully started, which
it could not do until its port times out. qdsrv has since been
changed to have a -R flag that repetitively tries to connect to
the port until it succeeds.
See also: recur(1) recur(-x)
rep another grep
rep is an alias for qrep which is yet another version
of grep(1).
The rep name is historic. It was replaced by qrep when
a program called rep was added to linux.
See also: qrep qrep(1) qrep(-x) rpl grep(1) regexp(x-qmisc)
resort build new output in order specified by input
resort uses the input file inputfile (defaults to the standard input)
to reorder lines of other files, writing the resulting output to the
standard output. The lines of inputfile should be the same style as
would be produced qrep with the -fo options. Such lines consist of a
file name, a block number (512 byte blocks), and a byte displacement
within the block, separated by colons. Text may follow a colon after
the displacement. resort reads this input, opens the file named
on the line, seeks to the specified position, and copies the lines to
the output from that point up to, but not including, the next line
that matches the regex argument.
resort is useful in reordering groups of lines according to some key
on a distinguished line. resort was written in 1976 to deal with
sorting TIPs files and other multi-line database records. Since that
time, grpsort had been created to perform much the same task,
See also: resort(1) resort(-x) grpsort qrep
revl reverse input lines
revl reads the argument files (defaults to the standard output), and
for each input line, outputs the contents (excluding the newline) in
the reverse order followed by a newline, to the standard output.
See r90 for interesting applications of revl, in fact they
were so interesting that revl was folded into r90.
See also: revl(1) revl(-x) r90
rls recursive list of files
rls is a recursive ls(1) but with extended facilities for
output field selection, selections of the depth of descent,
selection of files and directories to be listed, etc.
rls has a -F flag that allows the specification of fields to
be output. See lls(-x) or lls for a description of the fields.
rls is used in FSIC package qef script to create lists of all files
and/or directories in the selected tree.
Note: rls has a particularly useful -e flag which reduces the
output list to those files matched by the argument pattern,
somewhat like find(1)'s -name flag. For example:
% rls -sf -e'!SCCS/p\.'
will limit the output to files */SCCS/p.*.
See also: rls(1) rls(-x) lls FSIC
rmlist remove files named in input
rmlist reads its argument files or its standard input and removes the
files (and optionally the directories) named by those inputs.
rmlist is used to remove files and/or directories named by files.
qef invokes rmlist to implement the Remove* directives.
rmlist is also used in FSIC package qef script to remove empty
files when lists have been generated.
See also: rmlist(1) rmlist(-x)
rmnotnamed remove all files not named by arguments
rmnotnamed removes the all files in the current directory, that:
* do not have names beginning with a `.' unless the -a flag is
specified;
* are matched by one of the -p pattern options -- defaults to ``*''
(i.e., all);
* are not named in the exceptions list;
* are writable (unless the -f flag specified); and
* are not directories.
rmnotnamed is a dangerous command in that it will remove all the files
in the current directory almost as easily as rm *, though it's more
difficult to type. It was created to facilitate cleaning up
directories by removing all the files other than those explicitly
named as in:
% rmnotnamed qmkhist._
See also: rmnotnamed(1) rmnotnamed(-x) rm(1) rmlist
rmwhite output rpl script to remove redundant white space and newlines
rmwhite reads its input files and creates the rpl input that would
remove any trailing white space (i.e., spaces and tabs at the end of a
line), the third and subsequent newlines in a row, and (if -l specified)
extra newlines at the beginning and end of a file.
See also: rmwhite(1) rmwhite(-x) rpl
rootvrs create or modify the root.vrs file
rootvrs is used to create an initial root.vrs file at the top of a
source or object tree. If a root.vrs file already exists, rootvrs may
be used to modify a root.vrs file. Furthermore rootvrs can update
the current directory's root.vrs file to reflect changes in the
root.vrs file of the ``parent'' directory (i.e., the next root in
the RootPath).
Normal root.vrs files contain typically contain the following:
BuildHost -- name of the host used for qremote builds
BuildSys -- type of host system (to check build validity)
ConfigName -- name of the configuration
ConfVrs -- name of the configuration file
_DestDir_ -- the Destination directory
EditBranches -- version control option forcing branches
OldRoot -- old source root
PrereqList -- list of prerequisite projects
Project -- name of the product
QefAdm -- name of the qef administration directory
QremoteEnv -- envset to be used by qremote
Revision -- default revision number
RootAlias -- alias or alternative name for the root directory
RootPath -- list of root directories
SysVrs -- basename of qvrs file to be used host vars file
TreedirsList -- name of treedirs input file list
TreeType -- type of tree (e.g., baseline, working, object)
TreeType[] -- types of other roots
VCBranch -- displacement from VCRoot of files for tree
VCMap -- the specification for mapping the repository to disk
VCMap[] -- VCMap settings for other roots
VCRoot -- root of the version tree (if not LastRoot)
VCSys -- the version system
See also: rootvrs(1) rootvrs(-x) root.vrs(x-qvrs) qvrs treedirs
rotf select fields of input lines for output
According to Stephen Lane:
"Every good Q-Tree command uses rotf at least twice".
rotf, which is pronounced `wrote-eff', reads lines from its input
files (defaults to the standard input) or the files named within the
argument files (if the -f flag is specified), breaks those lines into
fields as delimited by the specified character (defaults to tab) and
outputs the fields in the order and format specified by the selector.
Purists might think that it duplicates some of awk(1)'s functionality,
and it does, but in a much easier and more reliable way. Furthermore,
rotf predates awk and as such the author never learned to use the
latter well.
See also: rotf(1) rotf(-x) transl cut(1)
rpl replace, print, or delete named lines
rpl reads lines of the form:
<file>:<address><action><text>
The named file is opened and the actions are performed. If the -r
(for replace) flag is specified, the modified file is written back
into the original file. Otherwise the modified file is written to
the standard output.
The actions include line insertion, deletion, replacement, and output.
A common scenario is to use qrep (or grep(1)) to extract lines from
a set of files, modify the retrieved lines and use rpl to replace the
original lines.
getlist(1), which may not be available, was created to get for
editing the files named in rpl input.
Note: There are many programs that generate rpl format such as
qrep, lines, findc, rmwhite, cerrs, and clump, to name a few.
Usually they support a -r flag to specify rpl style output.
See also: rpl(1) rpl(-x) qrep
rtabs align fields by inserting padding
rtabs reads lines from the argument files (defaults to the standard
input) and outputs the fields of the input lines padded and aligned
(by inserting blanks or dots) as specified by an argument.
The fields are delimited by a specified character (default tab) or
white space. The output format specification supports right or left
justification. rotf and transl are very useful when preparing input
for rtabs as they can provide the facilities to skip or reorder fields
or to insert arbitrary characters, which rtabs does not.
See also: rtabs(1) rtabs(-x) rotf transl
samefile check if two paths refer to same file
samefile tries to determine if the two argument pathnames (the second
defaults to ``.'') refer to the same existing file. The stat(2)
struct for both paths are retrieved using stat(2). If either file
does not exist, program exits with a -1 status. If either the inode
numbers (st_ino) or the device numbers (st_dev) differ, program exits
with a status of 1. Otherwise program exits with a 0 status.
If the -v flag is specified, the first detected difference or the
assumption that they are indeed the same file is output to the
standard output.
Warning: There are pathological cases in which samefile
will incorrectly report the files are different (e.g.,
pathnames incorporate different mount points thus rdev
is different). Furthermore, samefile might not work
on Windows as the inode number itself is not stable.
See also: samefile(1) samefile(-x) stat(2)
sdba output statistics about sdbm database
sdba outputs information about the blocks of the specified argument
DBM database.
The first line is the block size as in:
Block Size=4k
For each non-empty block in the .pag file a line of the following form
is output:
#0: 53 entries; 91% used; 82 free
For each empty block, sdba outputs:
#16: no entries.
See also: sdba(1) sdba(-x) ldbm kdbm
setbytes set specified offsets to strings
setbytes copies its argument input file (defaults to the standard
input) to a temporary file /tmp/set??????. Then, for each argument
offset value pair, setbytes seeks to the specified offset of the
temporary file and writes the value string. Options to take or drop
parts of the input file are also supported.
setbytes can be very useful, but is provided to facilitate setting
the name of the database in the sysnm binary. See sysnm(1) for a
description of how setbytes is used.
See also: setbytes(1) setbytes(-x) fndstr sysnm
sfdchk check strfix dictionaries for valid patterns
sfdchk (StrFix Dictionary CHecK) reads strfix dictionaries and checks
the values assigned to variables for validity as specified by an
input specification. This specification consists of the records
containing three fields -- the variable, a regular expression (see
regexp), and an understandable explanation of the legal values.
For example, the following specification:
KEEPFIDS ^-/^[0-9]+$/ an unsigned number
specifies that the value assigned to KEEPFIDS must be empty (the
special interpretation of the `^-' or a string of digits).
sfdchk compares each variable setting in the input dictionaries to
ensure that their assigned values match the associated regular
expression. Any discrepancies are reported.
See also: sfdchk(1) sfdchk(-x) strfix regexp(x-qmisc)
sfsic source file system integrity check and db maintenance
sfsic is used to compare the lists of existing source and version
system files against the FSIC files.fl list.
Typically sfsic is used in the fsic(x-qsg) script to create the ,s.errors,
,s.tmps, and ,s.pfiles files which should be used to correct any
discrepancies.
See also: sfsic(1) sfsic(-x) FSIC(x-qfsic) files.fl lib/sfsic.cf
shfix process input file incorporating output of embedded commands
shfix copies its argument files (defaults to the standard input) to
the standard output, processing any lines that begin with a `~' to
perform special functions. The most important special function is to
incorporate the output of a shell command. Other functions provide
facilities to build those shell commands and to incorporate the names
or versions of files and the values of argument registers into the
output or the shell commands.
The shfix -X flag describes the input file syntax.
See also: shfix(1) shfix(-x) shfix(x-qsg)
shuffle shuffle input lines and output
shuffle reads in a list of lines or words (as specified by flags),
shuffles the list, and outputs the result.
Useful for testing.
See also: shuffle(1) shuffle(-x) rand(3)
sls source path ls
sls outputs a list of all the files in the source path (as
specified by SrcPath in qvrs files), eliminating those files
for which a file with the same basename exists in an earlier
directory, or for which another file can be assumed to be the
source (e.g., x.y is source for x.c). The -s flag also reduces
the output to those files that have suffixes named by the @Suffixes
variable or in the default string. sls is the default srclist._
generator. The following is the command used by default for
qsg scripts (unless overridden by setting SLScmd).
sls -Ls
The -L flag specifies the output is saved in srclist._ and changes
to the file are reported.
See also: sls(1) sls(-x) SrcPath(x-qvrs) Suffixes(x-qvrs) _F_sls(x-qvrs)
_SuffixRules_[-defl] _SuffixRules_[] SLScmd(x-qvrs)
snm standardized nm output
snm provides a consistent interface to extract symbol table
information from the argument files and output it in a simple and
consistent manner no matter what the host environment and/or operating
system (we hope).
Unfortunately nm(1) is a program that has been subject to great
changes of the years. For some reason various suppliers lost sight
of the fact that nm output should be grepable and processable
by other tools. snm is an attempt to retrieve a consistent
and simple listing of the symbols in an executable, object file,
or a library. snm uses trait SNM_CONTROLS to specify the
command to be run to get the initial symbol table.
snm then processes that input to produce a standard form.
Note: Given some versions of nm(1) do not prefix their output
with the name of the file being processed if there is only
one argument file, snm attaches <Q>/lib/fakeobj.o to the
argument list.
See also: snm(1) snm(-x) liborder nm(1) topolsrt SNM_CONTROLS
<Q>/lib/fakeobj.o
srclist check the srclist._ file
srclist reads a list of file names from the standard input or as named
in the argument files and compares that list against the file list
contained in the file srclist._. If files named in srclist._ are not
named in the input list, or vice versa, these discrepancies are
reported and a new copy of srclist._ is created.
srclist is actually a special case of filelist that is equivalent to:
filelist -fmnuv srclist._
srclist was created and used to maintain the srclist._ database used
by qef and its script generator qsg. The default source database
command used to be:
sls -s | srclist
A full description of the above command is given in qef(1). However,
due to efficiency considerations, srclist's functionality has now been
added to sls directly.
See also: srclist(1) srclist(-x) filelist sls
strfix replace variables according to replacement dictionary
strfix is used to transform a prototype file into a configured file
by substituting embedded variables with values assigned to those
variables in a dictionary file given as an argument to strfix.
It is used frequently within qef systems to create configuration
specific header and data files.
Note: The strfix -[tT] flags specify that ~xx symbols are
to be replaced by the bound characters. See tilde-keysyms
and tildes, and $OldTildeConversions.
See also: strfix(1) strfix(-x) finclude tildes strfix(x-qsg)
sttyek set or display saved stty erase and kill chars
sttyek, in the absence of flags, sets the terminal's erase, kill,
intr, and quit characters to those contained in the file .qtree/sttyek
in user's login directory or in $HOME if user not specified. If the
-s flag is specified, or if the effective user's .qtree/sttyek file
does not exist, the current settings for these characters are written
out to the .qtree/sttyek file, before changing the settings.
sttyek's major function is to provide an easy mechanism for users to
preserve their preferred stty(1) controls in a way that is easy to modify
and invoke.
Another major application of sttyek (and its original motivation) is
to temporarily set the terminal to your preferred settings while you
are using someone else's terminal while saving the user's settings for
easy restoration.
See also: sttyek(1) sttyek(-x) stty(1)
subdist create sub-distribution from master file lists
The command:
subdist -f subspec flist
reads subspec (defaults to the standard input) as a specification of
files and directories to be extracted from the input flist (defaults
to the standard input) and outputs the selected files to the standard
output. The flist file should contain white space separated pathnames.
For obvious reasons subspec and flist may not both be defaulted to
the standard input.
The syntax and semantics of subspec is explained in subdist(-x).
subdist is most often used to extract sub-distributions from a
full distribution list.
See also: subdist(1) subdist(-x)
summarize summarize selected fields
summarize extracts selected input line fields, maintains running
totals for lines with common control fields and outputs the summary.
In many ways it is just yet another implementation of the standard
data-processing summarize process.
See also: summarize(1) summarize(-x) sumup
sumup output summations of selected input fields
sumup sums up input numbers. It reads the argument files (defaults to
the standard input) and computes the totals for the selected fields of
numbers. The selected fields are specified by the -[0-9] flags
(default all read fields).
See also: sumup(1) sumup(-x) summarize
suprep suppress repeated fields
suprep copies its input files to the standard output suppressing
repetitions of selected fields and performing some additional output
massaging when the selected fields change.
Note: rotf is useful in preparing input for suprep. ffill is almost
suprep's inverse.
See also: suprep(1) suprep(-x) rotf ffill
sysnm output symbolic system name or check if it matches arguments
sysnm outputs or tests the symbolic name of the current operating
system (System[Name]) according to a line in sysnames.tab selected
by a search done using uname(1) strings.
sysnm is equivalent to the command:
system -n
sysnm is a link to system, and if invoked using a name that matches
*sysnm, the -n flag is assumed.
Note: To facilitate the determination of the type of system at
login, prior to setting $PATH which may itself depend on sysnm,
sysnm should be copied to a directory in the initial
$PATH such as /bin or /usr/bin.
See also: sysnm(1) sysnm(-x) sysnames.tab system System(x-qvrs)
system output system name or check if it matches arguments
system outputs or tests the name of the current operating or host
system according to names specified by a line in <Q>/data/sysnames.tab,
which is selected by pattern matching the catenation of the uname(1)
system, release, and machine fields.
The default output is the same as the value of the qvrs variable @System,
the eight field of the sysnames.tab line.
system is sometimes used in shell scripts, as described in system(1),
to select actions based on the system.
sysnm is a link or copy of system that assumes the -n flag which
outputs the short symbolic system name. If system is invoked using a
name that matches '*sysnm', the -n flag is assumed.
See also: system(1) system(-x) sysnames.tab sysnm System(x-qvrs)
tabrpl replace tabs by spaces or vice versa
tabrpl reads the argument files, converts all tabs to the appropriate
number of spaces and outputs the resulting lines to outfile --
defaults to the standard output.
The processing is inverted by the -i or -I flags. If the -i flag is
specified, leading white space is converted to the appropriate number
of tabs and spaces. The -I flag converts all multiple spaces that can
be converted to tabs.
See also: tabrpl(1) tabrpl(-x)
tchown change ownership and mode according to a template
tchown changes the ownership and protection of files according to a
template given in its file arguments, or the standard input if file
arguments are not given. tchown is intended for use after
transferring a set of files to a new system or for ensuring that files
and/or directories exist and have the correct ownerships and modes at
the end of an installation. The instal program records its chown(2),
chgrp(2), and chmod(2) errors in tchown input format -- see instal(1).
When instal installs a file with special modes or settings that cannot
be set due to permissions, and the -I flag was specified, the failure
is recorded in the file named by InstLog (with the `.log' replaced by
`.fix'). The actual problem is recorded using tchown input format, thus
facilitating quick rectification by applying tchown to the .fix file.
Note: If rls(1) or lls(1) are available the format `bUGf'
produces output lines in the tchown input form.
See also: tchown(1) tchown(-x) instal _F_instal(x-qvrs)
InstLog(x-qvrs) lls instal chstat wmode
tdbkeys list TIPs database index keys and/or files
tdbkeys outputs the list of keys for the selected TIPs database dbase
(default ``db'') which should have been constructed using tdbm.
See also: tdbkeys(1) tdbkeys(-x) tdbm tdbrg
tdbm create TIPs key files
tdbm builds a DBM database. The keys are the fields named in the
argument taglist (defaults to the name tag). The data items are the
file name and offsets required to load the associated TIPs item.
See also: tdbm(1) tdbm(-x) tdbkeys tdbrg
tdbrg apply trg program against selected TIPs DBM database entries
tdbrg extracts entries for the argument keys from the tdbm
database dbn (default ``db'') and applies the -t argument trg
program to selected entries. trgmk is used to convert trg to object
form if necessary.
See also: tdbrg(1) tdbrg(-x) tdbm tdbkeys
ted TIPs file editor
ted is an interactive editor for TIPs format data.
It allows the user to create new entries, reorder entries within a
file, delete entries, and change individual fields within an entry.
ted was the first program to use x_db to create an online
documentation facility, in fact it was the motivation for x_db. As
such, there is extensive documentation available via the associated
command x-ted which is invoked by the `x' command within ted.
Note: ted uses the leditor package.
See also: ted(1) ted(-x) x-ted
termfnd check if termcap/terminfo entry exists
termfnd attempts to extract the termcap/terminfo entry for the
argument term. If no term argument is specified, $TERM is used. If
successful (i.e., the entry exists) termfnd exits with a zero status.
Otherwise it exits with a non-zero status. If there are multiple term
arguments, the exit status is non-zero if any of the terms entries do
not exist.
Note: termfnd is used to determine what leset input files can
be processed.
Note: The tgetent(3) routines on some platforms are incapable of
processing multiple calls, in which case the termfnd may
illegitimately fail.
See also: termfnd(1) termfnd(-x) leset tgetent(3)
termsa list all Ada variables in files
termsa outputs a sorted list of all the ADA variables found in the
argument files (defaults to the standard input) in alphabetic order.
A fuller description is given in termsc(1).
Note: termsa is often used to prepare a replacement dictionary
for finda.
See also: termsa(1) termsa(-x) termsc(1) finda
termsc list all C variables in files
The terms[cfwa] programs read the argument files (defaults to the
standard input), and output a sorted list of all the unique terms, be
it a C variable (termsc, a word (termsw), a field (termsf), or
an ADA variable (termsa) in the input.
terms[cfwa] are commonly used in combination with spell(1) and
find[cfwa] to do spelling correction or cross reference maps.
For example the following commands are part of the spelling correction:
* Generate list of all words:
termsw -n *.n | spell - > oldlist
* Correct copy of word list:
cp oldlist newlist; qed newlist
# replace qed by your editor of choice
* Create dictionary and find and replace producing rpl lines
double oldlist newlist | findw -rn - *.n | rpl -vr
double uses original and corrected list to create a replacement
dictionary that is used by findw to find and correct the terms in
the original files and produce rpl input which is used to change the
original files.
See also: termsc(1) termsc(-x) termsa termsf termsw findc rpl
termsf list all tabbed fields in files
termsa outputs a sorted list of all the fields found in the argument
files (defaults to the standard input) in alphabetic order.
A fuller description is given in termsc(1).
See also: termsf(1) termsf(-x) termsc findf
termsw list all words in files
termsw outputs a sorted list of all the words found in the argument
files (defaults to the standard input) in alphabetic order.
termsw provides mechanisms for ignoring nroff commands, some
punctuation, and capitalization, as does findw and commw.
A fuller description is given in termsc(1).
See also: termsw(1) termsw(-x) termsc findw commw
tf output name of non-existent comma file
tf outputs the name of a non-existent file in the argument dir
directory. This file name will usually be used as a temporary file
(i.e., a t.f.).
tf writes ",X" to the standard output, where X is an alphabetic
and the file ,X does not exist. The X used will be the lowest
letter in the range [a-zA-Z] for which the corresponding file does
not exist. The string is also output to the standard error output
prefixed by "tf=".
tf is commonly used to retrieve the name of a non-existent file
to save the standard output of a command as in:
% qrep pattern * > `tf`
however, its use has been largely replaced by ct and pa as in:
% qrep pattern * | ct
ct also uses the comma convention.
Note: The Q-Tree frequently uses the comma prefix to
indicate that the file is a temporary.
See also: tf(1) tf(-x) ct pa
tildes convert between symbolic and real character representations
tildes reads files (defaults to the standard input) and converts any
special character to its symbolic representation which is normally a
tilde (`~') followed by two printable ascii characters. The resulting
output is written to outfile which defaults to the standard output.
The list of ~XX symbols can be viewed using the -s flag or in
tilde-keysyms.
Note: There are two translation tables: the one for the latin1
characters used in xfig(1) and other X programs, and a
possibly obsolete set used on DOS systems in the early
nineties. The old set is selected by the -O flag or
by setting $OldTildeConversions.
See also: tildes(1) tildes(-x) tilde-keysyms $OldTildeConversions
timeout execute a program with a time limit
timeout executes another program (command) and kills the program (with
signal sig (defaults to KILL) if the time limit numsecs (defaults to
10) expires. timeout is useful in test suites to by-pass
nonterminating processes.
If the child command exits normally before the time out occurs, timeout
exits with the status of the child process.
See also: timeout(1) timeout(-x) kill(1) nohup(1)
tlist formated listing of TIPs data base files
tlist will list the contents of the specified TIPs files (defaults to
``*.d'' files in current directory).
Note: The listing formats provided by tlist are fairly weak.
For more sophisticated formated output see trg.
See also: tlist(1) tlist(-x) TIPs trg introtips(1)
tmkprof create new TIPs data base profile
tmkprof reads the argument file input (defaults to the standard
input) and converts it to a TIPs profile in argument file obj
(default .tprof).
A TIPs profile defines the record tags and their types, constituent
fields, and Mnemonics.
The command:
% bp tipsprof
will output a prototype tmkprof input file.
See also: tmkprof(1) tmkprof(-x) introtips(1) tprof
topolsrt topologically sort input
topolsrt takes a list of pairs of node names representing directed
arcs in a graph and prints the nodes in topological order on the
standard output. Its major use is to order the modules of a library.
topolsrt is a replacement for the program tsort(1) which attempts to
perform the same task. Unfortunately tsort does not detect
overlapping cycles which are sometimes significant when trying to
partition the nodes.
See also: topolsrt(1) topolsrt(-x) liborder tsort(1)
touchfiles list or create touch files
touchfiles is used to list existing _Touch_ files, to list the
directories of @TouchPath, or to create or touch new files.
Basic commands are:
touchfiles # list all touchfiles
touchfiles xx # list all touchfiles for xx
touchfiles -f # list all touchfiles without times
touchfiles -p # list @TouchPath directories
touchfiles -c xx # create or touch touchfile xx
See also: touchfiles(1) touchfiles(-x) _Touch_ TouchPath(x-qvrs)
tprof output TIPs profile in various formats
For all options, other than the -N flag, tprof lists the structures
of the argument TIPs profile files profile (default .tprof).
Options are provided to get the profile information in a variety
of formats -- see tprof(-x) include ones to produce C code and
defines for insertion into special purpose applications such
as contax.
If there is more than one profile argument, the output for each file
is preceded a line containing the name and a `:'.
The -N flag is used to get a list of the TIPs profiles.
See also: tprof(1) tprof(-x) tmkprof TIPs
traits output traits table
traits outputs the traits database <Q>/data/traits/<host>.tab.
The traits database is a set of variable/value pairs used to store
system, host, and site settings such as capabilities, pathnames, and
special values like QDSRV_HOST.
The data/traits/<host>.tab file is created by mktraits from the traits
source files traits.vrs and traits.ext.
Note: Whenever mktraits -Ru is run, any traits/<host>.tab file
that is older than either of the source files is removed.
Running traits or any query of the traits database via the
libdtree.a A.P.I. will recreate the file if necessary.
See also: traits(1) traits(-x) mktraits trait(x-qvrs) trait(x-qsg)
traits-vars traits/<host>.tab
transl translate input fields
transl reads its input lines, reformats (i.e., translates) them
according to an argument format and outputs the result. The format
allows the selection of fields and arbitrary strings and characters.
The -p pat flag restricts processing to those lines that match
the regular expression pat.
See also: transl(1) transl(-x) rotf
treedirs mkdir selected or all sub-directories of a qef tree
treedirs is used to create a shadow object or working tree. Normally, it
creates the directories for the files named in @TreedirsList (defaults to
treedirs.lst in @TreedirsPath). If such a file is not found, treedirs
searches the @RootPath trees for the construction files.
The -X flag to treedirs gives a complete description of the files it
processes and creates.
treedirs is usually the second step when one is modifying or building
a system, the first being to use rootvrs.
treedirs -L outputs the list of construction files for the argument
directory tree. The construction files are:
qeffile
qeffile2
root.vrs
tree.vrs
suppress.vrs
nobuilds.vrs
noqfile.vrs
The generated list can be saved in treedirs.lst (the default file
read by treedirs). Alternatively, treedirs can walk the directory
tree itself looking for the files of relevance.
See also: treedirs(1) treedirs(-x) treedirs.lst rootvrs mkqtree
TreedirsList(x-qvrs) TreedirsPath(x-qvrs) ExcludeDirs(x-qvrs)
suppress.vrs nobuilds.vrs noqfile.vrs
trg template driven TIPs report generator
trg executes trgmk to compile the template (if it is not an object
file already), and then, for each entry that matches the query
(default all entries) outputs, to the standard output, the template
with the appropriate interpretation.
trg is a TIPs tool for preparing data for other processing. Many of
the functions that may normally be found in information systems, can
be provided by the creation of a template that selects and prepares
data for other UNIX utilities.
An x_db database x-trg
Note: trg scripts are often converted into C code using trgdmp
and then embedded in applications such as contax, man3db,
and parmsdb.
See also: trg(1) trg(-x) TIPs x-trg (x-trg) trgdmp trgmk
trgdmp print trg object file
trgdmp dumps the argument trg object file (default t.out) in a readable
form into outfile (defaults to the standard output). It can also be
used to convert an object file to a C declaration for direct inclusion
in an application program (e.g., contax, man3db).
See also: trgdmp(1) trgdmp(-x) TIPs trg trgmk
trgmk compile trg script
trgmk compiles the trg source file (defaults to the standard input),
and writes the object code to object (default t.out).
trgdmp can be used to dump a trg object file's code in the pseudo
code or as a C initializations that can be embedded in applications
such as man3db or contax.
See also: trgmk(1) trgmk(-x) trg trgdmp TIPs trgmch(x-ltips)
tscan interactive TIPs data base scanner
tscan is the TIPs interactive query and scanning program. See
introtips(1).
tscan allows a user to access the argument data bases with a variety
of techniques.
Note: tscan is somewhat obsolete and clumsy and isn't used much.
TIPs applications are largely to organize data for
generation of other applications and hence tscan has
been woefully ignored.
See also: tscan(1) tscan(-x) TIPs ted
tstrhash test strhash hashing
tstrhash applies a strhash(x-ldtree) table against the input terms and
outputs a variety of results that may be used to test the efficacy of
the table with the given list of terms.
tstrhash calls strhash(x-ldtree) to hash the lines (words if -w specified)
of the argument files (defaults to the standard input) and
outputs the resulting hash value and the argument string.
tstrhash is used to test the hash table for a given vocabulary. The
objective is to look for a hash table that gives the lowest weight
(i.e., fewest hash collisions for the given vocabulary).
See also: tstrhash(1) tstrhash(-x) strhash(x-ldtree)
typset interface to typesetter and printing packages
typset is primarily an interface to the n/troff(1) family of programs.
Its normal processing is to read the argument files, eliminating the
``.so'' commands at the beginning of the input lines (as is done by
elimso), piping the result to a constructed command to process and
output the result.
The processes to be applied to a document may be specified via
command line flags, but typically one embeds a lines containing
'TYPESET:' followed by the flags (see typset(-x)). The process
selection flags are:
-d do not apply elimso
-e process through eqn(1)
-g process through grap(1)
-p process through pic(1)
-r process through refer(1)
-t process through tbl(1)
-f process through form
-mX apply the -mX flag to the troff run
typset provides a variety of actions selected via the -a flag.
Typical actions would be:
N nroff
P print the document 2-up
P1 print the document one up
xpv X preview the document
A list of the supported actions is produced by the -A flag.
The actions, special flags, tools to be applied for an action
are all specified via <Q>/lib/typeset or $HOME/.qtree/typeset.
See also: typset(1) typset(-x) elimso form $TYPESET ~/.qtree/typeset <Q>/lib/typeset
untouch set file times
untouch sets the last access and modification times of the argument
files to a specified time, similar to the standard tool touch(1).
untouch provides additional facilities such as setting the times
to that of another file or to a specific date.
See also: untouch(1) untouch(-x) touch(1)
upd update conventionally named versions of files
upd is used to rename files to create a pseudo version system. Given
a file called eg, the command:
upd eg
where files eg-2, eg, eg+1, and eg+3 exist, upd will
perform the following moves:
mv eg+3 eg+4
mv eg+1 eg+2
mv eg eg+1
mv eg-2 eg-1
If given a filename containing a `.', upd uses `o's (for old) and `n's
(for new) to create old and new versions of a file, as in:
file.nnc
file.c
file.oc
file.oooc
go creates an output file called ,.g but performs an upd-like
renaming such as:
mv ,.oog ,.ooog
mv ,.og ,.oog
mv ,.g ,.og
See also: upd(1) upd(-x) go
upto print selected lines from named files
upto outputs lines specified by the input files (defaults to
the standard input). The input lines should consist of a file name, a
colon (`:'), and a line number, optionally followed by a colon and
other text (i.e., rpl format). upto finds the specified line,
outputs it and outputs the lines up to (and including) the next line
that matches the pattern specified by the -u (-l) flag. If neither
the -u or -l flag is specified, just the selected line is output. If
the -r flag is specified, the lines output are the file name, line
number and line contents separated by colons (i.e., rpl format. Each
set of lines is preceded by the file name and the line number, unless
suppressed by the -q or -r flags.
upto is useful for extracting ranges of lines from multiple files.
See also: upto(1) upto(-x) rpl
vcc create, compile, link, and remove version string source file
vcc is an interface to cc that prepares a version file and then
invokes the argument cmd, replacing +VFILE+ by the created version
file. A typical use is:
vcc -m mimk cc mimk.o +VFILE+ -ldtree
vcc creates file _vmimk.c, which contains:
char version[]={"V@(#)Mimk 6.3 - 95/06/23 03:59:36 - linux"};
with the appropriate values for the version number and date (see
mkvernum(1)). The command `cc ...' is then run, with the `+VFILE+'
argument replaced by _vmimk.c. Upon completion, the version file is
removed (unless the -k flag is specified).
See also: vcc(1) vcc(-x) mkvernum MkvernumFormat _F_mkvernum_cc(x-qvrs)
ReportMkvernum Revision RevisionString
vci version control system interface
vci is a qsg clone that provides basic version control facilities
such as checking in or out a file, reporting what files are locked,
outputting the differences between a current file and its version
system release, and so on.
These facilities are provided by two qsg libraries: vci and
@VCSys (@VCSys is usually set in the root.vrs vile). The vci
library provides general utilities, whereas the @VCSys library
provides the implementations of the various facilities for the
specific version system. The facilities provided should be:
changed list changed files (see cmdcmp)
ci check in argument files
co check out argument files
diff produce differences between file and its v-file version
lock lock the argument files
new create a new version administration file (v-file)
novfiles list files for which there is no v-file
rlog produce history logs for argument files
tell tell which files are checked out for edit
unget unget or uncheck out argument file, discarding changes
vdiff run qgdiff on argument files and their v-files
See also: vci(1) vci(-x) qsg VCSys(x-qvrs)
vernumcomp compress the mkvernum database
The version database created maintained by qdsrv for mkvernum is
usually <Q>/data/mkvernum.db. Every time mkvernum, or its alias
vcc is invoked a line of the following form:
module version(count) system host directory user time
is appended to the database, which will therefore be growing
monotonically. If left unattended this database can get very big and
loading it can be time consuming. However, other than the last record
for each module, which contains the last count for that module, most
records are not required, other than for historic and auditing purposes.
vernumcomp reads input, copying comments and the last record for
each module in the database to its output. It also appends its input
to a savefile if specified.
The following is a recommended procedure for compressing the database,
while saving old records for possible future consultation.
cd `pathto qt/data` # chdir to the qtree data directory
gunzip mkvernum.odb # uncompress old record file
qdmgt freeze # freeze the qdsrv until new file created
vernumcomp -i- -o- -s mkvernum.odb # compress the database
qdmgt reload # unfreeze the qdsrv
gzip mkvernum.odb # compress the database
See also: vernumcomp(1) vernumcomp(-x) mkvernum.db mkvernum qdsrv vcc
wcci windows c compiler interface
wcci is a program that provides a rational (i.e. Unix cc-like)
interface to native compilers on Microsoft Windows systems.
By default, it is configured to drive Microsoft's compiler and linker
(CL.EXE and LINK.EXE) but it can also be configured to drive other
compilers through the Wcci* qvrs variables. See wcci(1) for details
on how wcci works and how it can be configured.
See also: wcci(1) wcci(-x)
whats whats 2 + 2
whats evaluates its argument list or its input lines as
arithmetic-expressions and outputs the results, possibly in a
specified base.
The expression may contain all the C binary, unary, and ?: operators
that may be used on ints.
See also: whats(1) whats(-x) arithmetic-expression(x-qmisc)
wmode write-protect files
wmode sets or resets the write mode bits of the argument files or
the files named by the argument files or the standard input.
Purists might object claiming that chmod(1) supports flag to do the
equivalent, but the following is table of wmode flags and the
chmod(1) equivalent:
wmode chmod
-0 a-w # actually -0 is the default
-1 a-w,u+w
-2 ug+w,o-w
-3 a+w
Furthermore, wmode can read its arguments from the standard input
which is frequently useful as in:
<pipeline> | wmode -f
See also: wmode(1) wmode(-x) chstat fexists chmod(1) chmod(2)
wordidx output input lines followed by lines indicating word count
wordidx is used to indicate the indices and spans of sequences in the
input lines that correspond to C variables, that is an alphabetic
character or underbar followed by zero of more alphanumeric characters
or underbars.
For example, consider the output for input "Now is the time ...":
Now is the time for all good men to come to the aid ...
1
1__ 2_ 3__ 4___ 5__ 6__ 7___ 8__ 9_ 0___ 1_ 2__ 3__
wordidx was created to quickly determine the index for a s(x-qed)
command within qed. In fact, using the leditor keymapping
within qed, Shift FP5 is mapped to "^SoV6.>wordidx^J" which
will show the indices of the words in the current line.
See also: wordidx(1) wordidx(-x)
wot output embedded sccs id strings
wot searches the argument files, or the files named by files, or
the standard input if the -f flag specified or the standard input
(if no arguments or -f) for occurrences of the pattern that the
SCCS program get substitutes for %Z% (i.e., @(#)) and prints
out what follows up to the first `"', `>', newline, back-slash,
or null character. It also supports a -p flag which specifies that
wot is to search $PATH for the files to be processed, and a -v flag
that limits the output to strings beginning with `V@(#)'.
Note: mkvernum and vcc embed such strings into their products,
thus wot may be used to determine the version of the tools
being run.
For example, the command:
wot -vp qef qefgui
will output the version strings for the $PATH's qef and qefgui.
See also: wot(1) wot(-x) what(1) mkvernum
x-contax contax use and data bases eXplanatory D.B.
This x_db database contains items describing the contax system,
its files and profile.
See also: (x-contax) x_db(1) x_db(-x) contax
x-eml form eml macros eXplanatory D.B.
This x_db database contains items describing the form eml
macro package: eml-mif, eml-man, and eml-xdb.
See also: (x-eml) x_db(1) x_db(-x) form
x-form form macros and syntax eXplanatory D.B.
This x_db database contains items describing form, its syntax and
primitives.
See also: (x-form) x_db(1) x_db(-x) form
x-html html qsg library eXplanatory D.B.
This x_db database contains items describing the scripts of the
qsg library <Q>/lib/qsg/html.qsl. This library contains
scripts to aid in creating HTML files.
See also: (x-html) x_db(1) x_db(-x)
x-ldeps deps library eXplanatory D.B.
a
This x_db database contains items describing the -ldeps library,
which provides symbol table management used by incls and other
programs.
Bug: It's still under development.
See also: (x-ldeps) x_db(1) x_db(-x)
x-ldtree x_db database describing routines of the -ldtree library
Companies that use the full Q-Tree set of tools often use the man3db
system to document subroutines and facilities of libraries. Tips
database entries describing the library's components are embedded in
the C source files as comments. The man3db program is then used to
extract those comments and convert them from the TIPs format into a
variety of products such as man3 sections in troff or frame, lint
libraries, software inventories and x_db databases.
x-ldtree and any other Q-Tree program whose name is of the form x-lname
are x_db databases that describe the library -lname.
Such databases can be examined using the qef gui by selecting those
databases using the Databases button in the View pull down menu of
the Qef Info Tools window.
See also: (x-ldtree) x_db(1) x_db(-x) man3db
x-lledit ledit library eXplanatory D.B.
This x_db database contains items describing the routines of the -ledit
library which are used to implement the leditor.
See also: (x-lledit) x_db(1) x_db(-x) leditor
x-lqvrs qvrs library eXplanatory D.B.
This x_db database contains items describing the routines of the -lqvrs
library which provide qvrs routines and expression manipulation.
See also: (x-lqvrs) x_db(1) x_db(-x) qvrs
x-ltc tc library eXplanatory D.B.
This x_db database contains items describing the routines of the -ltc
library which provide routines to output terminal control strings.
See also: (x-ltc) x_db(1) x_db(-x)
x-ltips tips library eXplanatory D.B.
This x_db database contains items describing the routines of the -ltips
library
See also: (x-ltips) x_db(1) x_db(-x) TIPs
x-man the -man macro set eXplanatory D.B.
This x_db database contains items describing the troff(1) -man macros.
See also: (x-man) x_db(1) x_db(-x) man(7) man3db
x-qed qed commands and facilities eXplanatory D.B.
This x_db database contains items describing qed flags, commands, errors,
and other features.
See also: (x-qed) x_db(1) x_db(-x) qed
x-qef QEF facilities and tools eXplanatory D.B.
This x_db database, of which this is an item, contains items describing
the tools, features, macros, controls, and files of the qef system.
See also: (x-qef) x_db(1) x_db(-x) qef
x-qefdirs qefdirs eXplanatory D.B.
This x_db database describes the syntax and semantics of the
other qef script generator qefdirs. Whereas qsg is for individual
directories, qefdirs is for trees providing the glue to control
builds over trees and sub-trees of directories.
See also: (x-qefdirs) x_db(1) x_db(-x) qefdirs
x-qefeg prototype qef files eXplanatory D.B.
This x_db database contains a number of prototype qeffile files
and example qvrs files.
See also: (x-qefeg) x_db(1) x_db(-x)
x-qefgui qef graphical user interface eXplanatory D.B.
x-qefgui is an x_db database that contains items describing different
aspects of the qef gui. These items are displayed by the various
help buttons within the gui.
See also: (x-qefgui) x_db(1) x_db(-x) qefgui
x_db(-x)
x-qefpp qef preprocessor controls and macros eXplanatory D.B.
This x_db(1) database describes qef preprocessor qefpp, its
controls and macros.
See also: (x-qefpp) x_db(1) x_db(-x) qefpp
x-qfsic file system integrity (fsic) package eXplanatory D.B.
This x_db(1) database describes FSIC (the File System Integrity
Check) package, its tools, files, procedures, error messages, and
corrective measures.
See also: (x-qfsic) x_db(1) x_db(-x) FSIC
fsic-intro(x-qfsic)
x-qmisc Q-Tree miscellany eXplanatory D.B.
x-qmisc is an x_db database that contains items describing different
procedures and facilities of the Q-Tree system.
Note: Some of the other x_db databases will refer to items in this
database.
See also: (x-qmisc) x_db(1) x_db(-x)
x-qproc software process procedures eXplanatory D.B.
x-qproc is an x_db database containing items describing typical
software procedures for a software product to be built using qef.x
See Chapter 12.10 of the Guide regarding the creation of a company
specific procedures manual.
See also: (x-qproc) x_db(1) x_db(-x)
x-qsg qsg and its support library eXplanatory D.B.
This x_db(1) database describes qsg (the QEF Script Generator), its
tools, input syntax, and the scripts of the standard qsg library.
See also: (x-qsg) x_db(1) x_db(-x) qsg
x-qvrs qvrs variables, facilities, and files eXplanatory D.B.
This x_db database describes the files, syntax and features and many
of the variables of qvrs(1).
See also: (x-qvrs) x_db(1) x_db(-x) qvrs
x-ted ted the TIPs editor eXplanatory D.B.
This x_db database contains items describing the TIPs database editor
ted features, commands, prompts, and errors.
See also: (x-ted) x_db(1) x_db(-x) ted
x-trg TIPs trg functions eXplanatory D.B.
This x_db database contains items describing the TIPs trg keywords
and functions.
See also: (x-trg) x_db(1) x_db(-x) trg trgmk TIPs
x-tscan tscan facilities and commands eXplanatory D.B.
This x_db database contains items describing the prompts of tscan,
the TIPs database user interface.
See also: (x-tscan) x_db(1) x_db(-x) tscan TIPs
x-xfig xfig qsg library eXplanatory D.B.
This x_db database contains items describing the scripts of the
qsg library <Q>/lib/qsg/xfig.qsl. This library contains scripts
to aid in creating xfig(1) files.
See also: (x-xfig) x_db(1) x_db(-x) xfig(1)
x-zr qed function library eXplanatory D.B.
This x_db database contains items describing the qed functions.
These functions are invoked using the qed command C(x-qed).
The confusing name (i.e., "zr") is because the original way one invoked
these functions was to use the 'r' register, hence the command would be:
\zrfunction arguments ...
See also: (x-zr) x_db(1) x_db(-x) C(x-qed)
x_db x_db database front end
x_db serves as the front end to an x_db (x for eXplanatory) database.
For example this is the x-qef x_db database. An important feature
of x_db is that when invoked using the command x-Name, Name is taken
to be the name of the database to be used. x_db when invoked as
x-Name, will search for DIR/Xdb.dir/Name.xo, where DIR is a directory
named by $PATH.
x_db databases are used to document many of the Q-Tree tools such as
x-contax contax use and data bases eXplanatory D.B.
x-eml form eml macros eXplanatory D.B.
x-form form macros and syntax eXplanatory D.B.
x-html html qsg library eXplanatory D.B.
x-ldeps deps library eXplanatory D.B.
x-ldtree x_db database describing routines of the -ldtree library
x-lledit ledit library eXplanatory D.B.
x-lqvrs qvrs library eXplanatory D.B.
x-ltc tc library eXplanatory D.B.
x-ltips tips library eXplanatory D.B.
x-man the -man macro set eXplanatory D.B.
x-qed qed commands and facilities eXplanatory D.B.
x-qef QEF facilities and tools eXplanatory D.B.
x-qefdirs qefdirs eXplanatory D.B.
x-qefeg prototype qef files eXplanatory D.B.
x-qefgui qef graphical user interface eXplanatory D.B.
x-qefpp qef preprocessor controls and macros eXplanatory D.B.
x-qfsic file system integrity (fsic) package eXplanatory D.B.
x-qmisc Q-Tree miscellany eXplanatory D.B.
x-qproc software process procedures eXplanatory D.B.
x-qsg qsg and its support library eXplanatory D.B.
x-qvrs qvrs variables, facilities, and files eXplanatory D.B.
x-ted ted the TIPs editor eXplanatory D.B.
x-trg TIPs trg functions eXplanatory D.B.
x-tscan tscan facilities and commands eXplanatory D.B.
x-xfig xfig qsg library eXplanatory D.B.
x-zr qed function library eXplanatory D.B.
See also: x_db(1) x_db(-x) xdbs xdbmk
xdbmk create an x_db data base
xdbmk converts a source form x_db database to the binary form.
Note: x_db and all its aliases such as x-qef, x-qvrs, and x-qsg
support a -S flag which will output the source form of the
selected items, hence:
x-qef -AS
will dump the entire source of this database, and xdbmk can be
used to recompile it.
Note: xdbmk's -X flag outputs the syntax of the input language.
To facilitate use, the input syntax is summarized here.
Input format:
%{ [key ...] start of a major item -- keys beginning with `*'
taken to be group names and duplicates not reported
%{- [key ...] start of a minor item
%} end of an item
%A key ... add addition aliases or keys for the item
%D description set the short description for the database
%i file include named file
%%... line beginning with literal %
%# comment comment line - ignored
%c [key ...] produce columns of selected keys (default major items)
%l [key ...] produce list of selected keys (default major items)
%S ... line is maintained in database but never output
used to embed SID lines in source and binary
%; %; embedded in a text body is not output to facilitate
use of unexpanded SCCS keywords (e.g., %A)
for literal `%;' use `%%;;'
%<tag str %; If outputting for tcl, output str followed by tag;
common tags are: manref, B (bold), I (italics), btn (button)
... %?word treat word (or up to %;) as manref as in word
... %!word treat word (or up to %;) as italics as in word
... %$word treat word (or up to %;) as bold as in word
... %*word treat word (or up to %;) as btn as in word
... %% ... a literal % character
See also: xdbmk(1) xdbmk(-x) x_db
xdbs list all or specified x_db databases or all their topics
xdbs is used primarily by the qef gui to retrieve the names,
pathnames, and descriptions of all or specified x_db databases.
It will also produce all the available topics for all or specified
databases. A flag is provided to cause the output to be formatted
as TCL lists to facilitate processing within the qefgui.
See also: xdbs(1) xdbs(-x) x_db
xfinterp process -x flag outputs
xfinterp reads its standard input which is assumed to be the output
of Q-Tree programs run with the -x flag. This input is processed
to format the input to produce one of the following forms:
* description lines with troff formatting (-d)
* description lines (-s)
* skeleton troff manual page (-m)
* skeleton eml-form manual page (-f)
* troff formatted form of -x outputs (default)
* description lines (-d)
One useful application of xfinterp is to produce a list of all the
programs in Q-Tree bin using:
cd `pathto qtbin`
l -se | lash -lf "./%1 -x" | xfinterp -s
See also: xfinterp(1) xfinterp(-x)
xtty convert stty(1) output to full explanations
xtty processes its input, which should be the output of stty(1) and
converts it to a standard annotated representation. For example, the
following example stty output:
speed 9600 baud; line = 0;
erase = ^H;
-brkint -imaxbel
when processed by xtty is converted to:
speed: 9600 baud
line discp: 0
erase char: ^H
-brkint: does not signal INTERRUPT on break
-imaxbel: flush input buffer on overflow
xtty is for those of you who cannot remember what "ofdel" means.
See also: xtty(1) xtty(-x) stty(1)
younger test if files younger than specified time
younger compares the last modification time of the argument files or
the files named by the files (if -f specified) against basefile's last
modification time. The names of any files that are younger than
basefile are written to the standard output.
rls has a -y yfile option that limits its output to those files
that are younger than yfile.
fexists has options to limits its output to those input pathnames
that have been modified within a certain specified range.
See also: younger(1) younger(-x) rls fexists
zfill zero fill digit string
zfill copies its argument files (defaults to the standard input) to
the standard output, left zero filling a digit string immediately
after a specified selector (defaults to the first colon) to a width of
six columns.
The default is to zero fill the field immediately after the first colon.
This allows one to convert grep -n output to facilitate sorting of
that output.
See also: zfill(1) zfill(-x)
