The following descriptions are extracted from the x-qef database.
arupdate update an archive library
bfsic build file system integrity check and db maintenance
bp deliver source code boiler plate
cc_g gcc interface that eliminates gratuitous warnings
cc_z cc interface that eliminates gratuitous messages
ccsed cc interface that applies sed script to assembler file
chstat change the status of files named in list or arguments
cleanilog clean up an instal.log file
cmdcmp compare the outputs of two commands
com compile or process file using embedded command
condln link or copy file1 to file2
confvrs create or compare qvrs config file
count produce numbers
cpifdif compare new and old and copy if different
ct cut input into cut file
cush could (could not) use shell interface
depsmap create file mapping suffixes to mkdeps file
detox remove toxic waste normally found in dos files
dirlist produce list of all directories for input file list
dirsetup set up a directory from prototype file
dmpdeps dump or test deps object
double output differing lines of files separated by tab
environ list arguments, user info, open files, $vars, and ignored signals
envset output environment setting commands
envstd list arguments, open files and ignored signals
fcmp compares new and old
fdate output formated date string
fexists output file names that match specified attributes
ffill fill in suppressed fields
filelist maintain a file list and their collective modification time
finclude output file resolving includes
fixflist remove non-existent files from a file list
flcomm comm(1) like but columns put into files
fnd find a command
fndstr find a string in a file and output offset
ftest test argument file attributes
g process go files
go detach a command
goes view or remove jobs from go message files
gomonitor display josh halt files as updated and other files
gotstr output names of files that contain argument string
grpsort sort groups of lines specified by ranges
hhmmss output a banner of the time
howto output selected howto information
incls dynamic dependency tracker
instal paranoidly install a file and audit it
instdir install a directory
instfls install files, but only if necessary, according to script
josh a job shell
kdbm extract from or add to dbm database
l list files in columns
lash long argument list shell interface
lc list files by type in columns
ldbm extract from or add to dbm line database
libs output information on libraries used by the named files
lines print first N and last M lines
linked list files with multiple links
lls ls for input files with selected fields output
manprep prepare manual sections for qef info tool
mimk issue updating commands according to a dependency script
mkalltraits run mktraits on remote hosts
mkddt create ddt declaration
mkdeps compile deps scanner file
mkopts create options header file
mkqtree set up new qef tree
mkquete produce manual section index
mksolib create shared library externs list
mktraits compile traits files
mkvernum create or change version string
mnfadd add a new manifest to manifest database
mnfchk check manifest database for syntax and consistency
mnfcmp compare two manifests
mnfdb output manifest database release information
mnfdel delete releases from manifest database
mnfput output a manifest or manifest database
necho echo with escape interpretation
numb produce numbered lines
pa output, list, or delete cut files
pathclash produce list of duplicated executables in path
pathto map argument file to special directory
pdirs directory stack manipulation for shells without pushd
putifdif copy input to output file if different
qconfset add variable setting to the conf.vrs file
qd shell alias/function to chdir using selected qdsrv database entry
qdchk check host's qdsrv database entries
qdid assign qdsrv ident and/or bind to path
qdmgt general qdsrv management interface
qds select and print entries from qdsrv database
qdsrv qef project database server
qdupd add path to qdsrv database
qef the driver
qefdirs qef script generator for multiple directories
qefgui run the qef qui
qefinfo run the qef info tool
qefpp the qef macro processor
qefsort sort or merge text files
qenv output environment variables in sorted usable form
qfunc output selected qfunc function/alias file
qgdiff graphical file difference viewer
qhy report why a target was rebuilt
qlex interface to lex
qliceadd add licences to a licences database
qlicedmp dump licences database
qmsdev Microsoft Developer's Studio project file generator
qmsg send a message or mail to designated users
qremote run a command on a remote host (if necessary)
qsg the primary qef script generator
qsgcomp compiles a qsg script to object
qsgdump dump a qsg object file
qsh qef shell command interpreter
qtreeinf output information on $QTREE and its directories
quete list x_db topics and quete.db entries that match patterns
qvrs process the qvrs files
qvrsdmp process qvrs binary file
qvrsexpr evaluate and output qvrs expressions
qyacc interface to yacc
r90 reflect lines around diagonal
rc windows resource compiler
rcslocks report the RCS locked files in a directory
recur execute a command repetitively
rep another grep
rls recursive list of files
rmlist remove files named in input
rootvrs create or modify the root.vrs file
rotf select fields of input lines for output
rpl replace, print, or delete named lines
rtabs align fields by inserting padding
sdba output statistics about sdbm database
setbytes set specified offsets to strings
sfdchk check strfix dictionaries for valid patterns
sfsic source file system integrity check and db maintenance
shfix process input file incorporating output of embedded commands
sls source path ls
srclist check the srclist._ file
strfix replace variables according to replacement dictionary
subdist create sub-distribution from master file lists
suprep suppress repeated fields
sysnm output symbolic system name or check if it matches arguments
system output system name or check if it matches arguments
tchown change ownership and mode according to a template
touchfiles list or create touch files
traits output traits table
transl translate input fields
treedirs mkdir selected or all sub-directories of a qef tree
untouch set file times
upd update conventionally named versions of files
vcc create, compile, link, and remove version string source file
vci version control system interface
vernumcomp compress the mkvernum database
wcci windows c compiler interface
whats whats 2 + 2
wmode set the write modes for files
wot output embedded sccs id strings
x-html html qsg library eXplanatory D.B.
x-ldtree x_db database describing routines of the -ldtree library
x-qef QEF facilities and tools eXplanatory D.B.
x-qefdirs qefdirs eXplanatory D.B.
x-qefeg prototype qef files eXplanatory D.B.
x-qefgui qef graphical user interface eXplanatory D.B.
x-qefpp qef preprocessor controls and macros eXplanatory D.B.
x-qfsic file system integrity (fsic) package eXplanatory D.B.
x-qmisc Q-Tree miscellany eXplanatory D.B.
x-qproc software process procedures eXplanatory D.B.
x-qsg qsg and its support library eXplanatory D.B.
x-qvrs qvrs variables, facilities, and files eXplanatory D.B.
x_db x_db database front end
xdbmk create an x_db data base
xdbs list all or specified x_db databases or all their topics
xfinterp process -x flag outputs
^^ arupdate update an archive library
arupdate is used as an interface to ar(1) in library building scripts.
arupdate is used instead of ar as it is an interface is based on a
specification of what should be in the library, from which it
determines what actions to take to bring the library up-to-date.
arupdate's arguments are interpreted to create a list of the
files that are to be part of the archive. The actual arguments may
be files to be included, files that contains the names of files to
be included, or the names of other archives, some or all of whose
elements are to be included.
Given this member list, arupdate checks the archive to determine
the files that need to be removed (i.e., in archive but not the list)
the files that need to be replaced (i.e., existing file's time-stamp
is not equal to that in the archive), and the files to be added
(i.e., in the list but not in the archive).
Note: A file named in the argument generated member list need not
exist, provided it is already in the archive.
arupdate then invokes ar once to delete member files that are no longer
part of the library or will be re-added and a second time to add
in the new or replacement member files.
It will then remove all the files that have been added (other than
those extracted from other archives) unless the -k flag has been
specified.
arupdate also supports an option to add a mkvernum generated
version file to the archive.
Note: If the -V module is specified and the .c module that is
created (i.e., _vmodule.c) is compiled using the
flags _F_mkvernum_cc[module] or _F_mkvernum_cc.
See also: arupdate(1) arupdate(-x) ar(1) mkvernum _F_mkvernum_cc(x-qvrs)
^^ bfsic build file system integrity check and db maintenance
bfsic is used to compare the lists of existing installed and object
file systems against the FSIC database inst.fl, objs.fl, deviates.fl,
except/<sysnm>.fl, and <Q>/lib/bfsic.cf.
Typically bfsic is used in the fsic(x-qsg) script to create the
,p.errors, ,i.tmps, and ,o.tmps files, which in turn are used
to correct the file systems and database.
Note: The fsic directory is typically in @QefAdm/fsic in the
root directory.
See also: bfsic(1) bfsic(-x) FSIC(x-qfsic) inst.fl(x-qfsic)
objs.fl(x-qfsic) deviates.fl except/<sysnm>.fl <Q>/lib/bfsic.cf
^^ bp deliver source code boiler plate
When bp is invoked with an argument X, it searches for a file called
Bp.dir/X in the directories named by $PATH. If such a file is found
and it begins with the sequence `#BP' followed by a tab, the file
is copied to the standard output, after replacing certain `%%'
sequences with run-time values (e.g., the date or user's name) or
interpretations.
bp is used to retrieve and output prototypes of various files, text
or code segments.
If bp is invoked without arguments, it outputs a list of all the
bp files available.
howto is a link to bp that searches for Howto.dir/X files.
Note: Many of the boiler plates relate to the qef system.
See x-qefeg.
See also: bp(1) bp(-x) howto qfunc new-bp(x-qmisc) New-Bp(x-qefgui)
^^ cc_g gcc interface that eliminates gratuitous warnings
cc_g is a link to cc_z that eliminates the numerous messages
generated by gcc that are of little or no value or cannot be resolved.
The messages to be eliminated are those matched by regular expressions
associated with cc_g in the file <qtree-root>/lib/cc_z.cf.
See also: cc_z cc_z(1) cc_z(-x)
^^ cc_z cc interface that eliminates gratuitous messages
cc_z and its links are interfaces to the standard C compiler that
filters cc output to eliminate various gratuitous messages such as
the copyright notices and warnings that cannot be resolved. The
file <qtree-root>/lib/cc_z.cf should contain lines that indicate the
real compiler program to be used and regular expressions to be
applied. That file contains comments that describe its contents in
more detail.
See also: cc_g cc_z(1) cc_z(-x) cc_z.cf
^^ ccsed cc interface that applies sed script to assembler file
ccsed is an interface to the standard C compiler that applies
a sed(1) script to the assembler code before it is assembled.
The ccsed command is the same as the cc command except that one
of the -E, -S, or -c flags and one and only one *.c file must be
specified in the argument list. For the -c option, ccsed invokes the
appropriate cc command with a -S flag to create the AsSuffix file.
The resulting file is then processed by sed (using cush to do file
redirection). The output file is the normal assembler file (e.g.,
`file.s') with a prefixing underbar (e.g., `_file.s'). This file is
then processed by _T_as to produce the ObjSuffix file.
ccsed is most commonly used to massage assembler files to fix strings
or external references.
See also: ccsed(1) ccsed(-x) cc_z AsSuffix CcSed_file
^^ chstat change the status of files named in list or arguments
chstat is a combination of chmod(3), chown(3), and chgrp(3) that
processes the files named in argument files or in the standard input.
chstat is useful for processing large numbers of files named by
some pipe line or file.
See also: chstat(1) chstat(-x) tchown wmode chmod(1) chgrp(1) chown(1)
^^ cleanilog clean up an instal.log file
Whenever instal(1) is run, if the qvrs(1) variable @InstLog is set,
instal appends an audit trail record to the @InstLog file (usually
instal.log at the base of the Object tree). This audit file can grow
substantially and may contain many obsolete records. cleanilog may be
used to eliminate obsolete records and optionally remove records
that refer to non-existent files from an instal audit trail.
To update the current tree's @InstLog file, purging references to
non-existent files, use:
cleanilog -Iuvp
See also: cleanilog(1) cleanilog(-x) instal InstLog(x-qvrs)
^^ cmdcmp compare the outputs of two commands
cmdcmp compares the output of a command to the output of another
command, the contents of a file or the standard input. It can also
compare the contents of a file to the contents of another file or the
standard input, although that is just duplicating the capability of
cmp(1) or fcmp.
cmdcmp was created to circumvent the problems of the ambiguity of the
exit status of a pipeline and the problems associated with the
management and removal of temporary files.
See also: cmdcmp(1) cmdcmp(-x) fcmp cmp(1)
^^ com compile or process file using embedded command
com extracts specially identified command lines, called com lines,
from its argument files, processes those lines to replace special
strings by parts of the argument file name or extracted from the
qvrs(1) files, and interprets the resulting line as a shell command.
A com line is a line within the first 1024 characters of the file that
contains the string `/*^' or `/*%'. The balance of the line is
processed to replace `^' characters followed by special strings by
special interpretations (as listed by com -X). The resulting line
is then executed as a sh(1) command.
<qtree-root>/lib/comlines contains the com macros.
See also: com(1) com(-x) qvrs
^^ condln link or copy file1 to file2
condln, given two argument files f1 and f2, ensures that f1 is
linked or copied to f2, even if f2 already exists. condln is
used instead of ln(1) as that program fails under a number of
conditions that condln avoids (e.g., f2 exists or is on a different
file system).
In summary, condln tries to ensure that file2 is either a link (hard
or symbolic) to file1 or is a link to a copy of file1 or is itself a
copy of file1.
See also: condln(1) condln(-x) ln(1) mklink(x-qsg)
^^ confvrs create or compare qvrs config file
The second file processed by qvrs(1) is the file that the user
provides or names to set configuration parameters. The actual
file used is based on @ConfVrs or searching for conf.vrs or
confdefl.vrs in the directories named by @?ConfVrsPath.
confvrs provides a number of services with respect to the current
config file and the default version. The default behaviour is to
output the name of the current config file and the names and values
for the variables it sets.
Other facilities (selected by flags) show the variables and values
for the default config file (-D), show the differences between the
real and default config files (-d); and copy the default config file
to conf.vrs (-o).
See also: confvrs(1) confvrs(-x) qvrs qconfset mkqtree ConfVrs(x-qvrs)
ConfVrsPath(x-qvrs) conf.vrs(x-qvrs) confvrs/(x-qvrs)
confdefl.vrs(x-qvrs) confdefl-eg(x-qefeg)
^^ count produce numbers
count outputs the integers from a specified start (defaults to 0)
to a specified stop (defaults to 32767) in using the specified
increment (default 1 or -1 (if the start > stop).
A printf(3) format can be specified for the output.
count was added to the QEF product at a client's request, for
what I know not, but it can be useful.
See also: count(1) count(-x)
^^ cpifdif compare new and old and copy if different
cpifdif is a very fast implementation of
cmp -s new old || cp new old
without the complications that arise due to cmp's exit codes.
It is used extensively to install new versions of a file only
if the file is changed.
See also: cpifdif(1) cpifdif(-x) cmp(1) putifdif cmdcmp
^^ ct cut input into cut file
ct copies its input files or the standard input into a temporary
file in the directory named by $CTDIR or
/.qtree/ctdir.
The companion program pa can be used to retrieve the saved file
by explicit basename or an age index (0 for the youngest, 1 for
the next youngest, etc.)
See also: ct(1) ct(-x) pa
^^ cush could (could not) use shell interface
cush simply runs the argument command, which should consist of a
program in the current $PATH and arguments to that program. Flags
and options allow command line specification of the setting and
unsetting of environment variables, redirection of I/O, chdirs,
special process management, and process attributes often not
available or not easily done using the standard shells.
One of the more important cush options is to facilitate the saving
of the input in a temporary file, the name of which is inserted into
the argument command. This facilitates using commands that require a
file and cannot process the standard input. cush is also used to
do redirection of I/O in command processors which do not support I/O
redirection, when the redirection cannot be expressed in the current
shell's context (i.e., on a remote machine or as a different user), or
when doing so imposes an additional overhead (e.g., forking a shell).
See also: cush(1) cush(-x) qremote
^^ depsmap create file mapping suffixes to mkdeps file
depsmap processes the argument files which must be dependency state
tables and description files as produced by mkdeps. The Class name,
Description field, and the Suffixes list for each file are extracted
and saved. Once all the files are processed, depsmap writes the
resulting lists to the output file ofile (defaults to the standard
output).
The resulting file is used by other programs to map a file to the deps
class to be used to process the file. The depsmap output file is
normally installed as <qtree-root>/lib/deps/deps.map.
See also: depsmap(1) depsmap(-x) mkdeps dmpdeps incls deps.map
^^ detox remove toxic waste normally found in dos files
detox removes any carriage returns before a new line and a
control-z at the end of its input. Alternatively it can insert
the carriage returns and control-z.
An option is provided to change files in situ.
^^ dirlist produce list of all directories for input file list
dirlist reads pathnames from its input files and outputs a unique
sorted list of all the directories involved in the input pathnames.
Given the path name dir1/dir2/file, dirlist would output:
dir1
dir1/dir2
dirlist is used to produce the list of directories that may have
to be processed to deal with named or listed files.
See also: dirlist(1) dirlist(-x) dirname(1)
^^ dirsetup set up a directory from prototype file
The input files to dirsetup consist of lines specifying directories,
files and their contents, and annotations. When dirsetup processes
such a file, dirsetup creates the specified directories and files in
directory dir. dirsetup will not overwrite any existing file unless
the -o flag is specified. Any annotations are output to the standard
output.
dirsetup files are usually used to define file systems for special
applications such as the qef tutorials or a generic qef administered
project.
In the absence of any arguments or flags, dirsetup lists the currently
available dirsetup files.
Currently the dirsetup databases are:
dotqtree set up for a user's .qtree directory
fsic files of the file system integrity check
miniproj files for a minimal qef project
newproj infrastructure files for a qef project
qeftut1 qef tutorial set # 1
qeftut2 qef tutorial set # 2
qeftut3 qef tutorial set # 3
qegappl example qef application package
qeglibeg example qef library set up and mgt.
qegqsl example of project specific qsglib
See also: dirsetup(1) dirsetup(-x) new-dirsetup(x-qmisc)
dirsetup-sets(x-qefeg)
^^ dmpdeps dump or test deps object
Dependency files are created by the mkdeps program. They contain a
state table to find and extract embedded dependencies such as the
`#include' of the C programming language plus information used to
convert an embedded `included' symbol to a file.
The dependency suffix map file, deps.map, is used to map file names to
deps files. Basically it contains the names of the supported deps
files and patterns that match the files that it processes.
dmpdeps outputs readable representations of either a selected
dependency file or the dependency suffix map file.
Some useful commands:
dmpdeps -m # show list of current deps files
dmpdeps -cc # dump information about c deps file
dmpdeps -s -c tex # dump source for tex deps file
See also: dmpdeps(1) dmpdeps(-x) mkdeps incls depsmap deps.map
^^ double output differing lines of files separated by tab
double reads lines from its two input files in parallel. It the input
lines differ, they are output as a single line with a separating tab.
double is commonly used to produce replacement dictionary for other
tools such as findf(1).
See also: double(1) double(-x) comm(1)
^^ environ list arguments, user info, open files, $vars, and ignored signals
environ outputs the argument list (including the first argument) in an
unambiguous form (using `\ddd' to represent unprintable characters),
lists the file descriptors that are open, the signals that are not
SIG_DFL, the real and effective uids and gids, the umask setting, and
the environment variables. The output is written to /dev/tty to
ensure its visibility.
environ was created to test that programs were setting up the correct
signals, arguments, and files before forking and execing another
program. This is usually done by moving the program of interest (i.e.,
the program that will be exec'ed) to a temporary location, linking or
copying environ to the old program name and running the parent program.
Alternatively one may be able to link environ to the program name
in an earlier directory of the $PATH.
See also: environ(1) environ(-x) envstd
^^ envset output environment setting commands
envset is used to extract a named set of environment variables settings
and unsettings specified in a file (defaults to
/.qtree/envset and
<qtree-root>/lib/envset) envset outputs the selected set as a series
of sh or csh commands to perform the various settings/unsettings.
envset -x explains the syntax of the envset file and describes
a convenient alias (or function) Ev as:
alias Ev 'eval `/usr/qtree/bin/envset -cNQ \!*`' # in csh
Ev () {
eval $(/usr/qtree/bin/envset -NQ $*)
}
so that Ev <EnvSet> changes the current shell's environment to that
specified by the argument. The fully rooted path and the setting of
QTREE via the -Q flag (uses directory of program minus /bin) are used so
that the function will work no matter what the current PATH or QTREE.
Note: cush has a -e flag that selects a set for interpretation
before executing the argument command.
See also: envset(1) envset(-x) cush qfunc
^^ envstd list arguments, open files and ignored signals
envstd is a link to environ. environ lists its arguments, open
files, real and effective uids and gids, its umask setting and its
environment variables. environ writes its output to a file
(usually /dev/tty) opened specifically to ensure its visibility.
When environ is invoked as envstd, the various outputs can be
selected by flags and the output is written to the standard output.
See also: envstd(1) envstd(-x) environ
^^ fcmp compares new and old
fcmp is a link to cpifdif and is equivalent to specifying a -n or -N
to that program. Basically, fcmp compares the files new and old and
exits with status 0 if they are identical, and 1 otherwise.
fcmp is basically the same as cmp(1) except faster, consistent, and
providing some important options.
See also: fcmp(1) fcmp(-x) cpifdif cmp(1)
^^ fdate output formated date string
fdate formats a specified time -- defaults to the current time --
according to a specified format. The format argument consists of `^'
followed by a single letter to select the element of the time to be
output. For example:
fdate '^a ^h ^d ^T ^c^y'
would output:
Mon Jan 31 05:48:21 2000
The command:
fdate -X
will output the format keys and their descriptions.
fdate predates the extension of date(1)'s extension to provide
similar functionality, however, date is limited to displaying the
current time, where as fdate can be used to output the date for
an arbitrary time such as the time stamps stored in qmkhist._ files.
See also: fdate(1) fdate(-x) date(1)
^^ fexists output file names that match specified attributes
fexists is used in the FSIC package qef script to filter list of files
to remove those that aren't empty. This is used in a pipeline with
rmlist to remove the empty files.
fexists can also be used to select input paths that are or are not
files, directories, has a specified mode, has been modified within
a specified time, or is empty.
See also: fexists(1) fexists(-x)
^^ ffill fill in suppressed fields
ffill fills in empty fields with the contents of the most recent
non-empty corresponding field in a previous line. In effect it is the
inverse of suprep.
The fields to be filled in are selected by the `-0..9' argument
(defaults to `-0'). For example:
ffill -03
specifies that the zeroth and third fields are to be filled in. All
other fields are to be copied out directly.
See also: ffill(1) ffill(-x) suprep double
^^ filelist maintain a file list and their collective modification time
filelist maintains the list of files in the argument file flist,
optionally report gains or losses and setting flist's time stamp
according to the status of the files it names.
srclist is a special case link to filelist that uses the file
called srclist._ and implies the flags -mnuv.
See also: filelist(1) filelist(-x) srclist srclist._
^^ finclude output file resolving includes
finclude copies its input files to its designated output replacing any
lines that begin with `include' (or a specified string) by a header line,
the contents of the included file, and a trailer line.
finclude is often used to prepare input for other processes, in
particular strfix.
See also: finclude(1) finclude(-x) strfix
^^ fixflist remove non-existent files from a file list
fixflist reads in filelist as a list of white space separated
pathnames. Any pathname that does not refer to an existing file is
removed from the list. If the -a flag is specified filelist
itself is added to the list (subject to -a and -r special case).
If the resulting list is empty and the -r flag is specified,
filelist is unlinked. Otherwise the list is sorted and written out to
filelist.
fixflist was created to maintain file lists within the File System
Integrity System (see FSIC). One of the byproducts of that
package is a file list containing all the known temporary files (i.e.,
a.out, core, or any file beginning with a `,').
See also: fixflist(1) fixflist(-x) FSIC
^^ flcomm comm(1) like but columns put into files
flcomm is a comm(1) like program that allows columns to be diverted
to separate files and aborts in case of sequence errors or duplicated
lines. It was created to support the file mechanism used within the
Q-Tree directory file system integrity check (see FSIC) previously
called fl, hence the "fl" prefix.
flcomm is used in FSIC package qef script to compare file lists against
the known file lists and output the differences to specified files.
See also: flcomm(1) flcomm(-x) comm(1) FSIC fsic(x-qsg)
^^ fnd find a command
fnd searches the directories specified by $PATH for the argument
file. If it finds an executable file corresponding to the argument
file fnd writes the full path name to the standard output.
Flags allow the user to specify the inclusion or exclusion of
the current directory, or the reporting of all instances in the
path.
See also: fnd(1) fnd(-x) pathclash which(1) $PATH(x-qvrs)
^^ fndstr find a string in a file and output offset
fndstr searches the argument files -- defaults to the standard input
-- for the argument string, and outputs the offset of that string if
found.
fndstr provided to facilitate setting the name of the database in
the sysnm binary. See sysnm(1) for a description of how fndstr
and setbytes are used to perform this.
See also: fndstr(-x) fndstr(1) setbytes sysnm
^^ ftest test argument file attributes
ftest tests the argument file for the attributes specified via the
flags, outputting the appropriate diagnostic and/or taking some other
action.
ftest was created to eliminate the complicated and cumbersome testing
that is sometimes required in shell or make scripts to test whether or
not a file can be changed or exists.
See also: ftest(1)
^^ g process go files
g is used to view and optionally remove the diagnostic output files
of go and josh, referred to as the go-files.
Within the qef gui, go is used to detach builds creating the files
displayed by the build monitor. g can be used to view those files.
Note: The -d flags to go and josh cause the output files to be
created in the user's
/.qtree/goes/<host> directory. The
-d flag to g causes it to look in the appropriate directory.
See also: g(1) g(-x) go josh goes gomonitor $GODIR
^^ go detach a command
go executes its argument command in background, usually redirecting
the standard input and outputs, possibly sending a message when the
argument command has completed. go is used to detach builds within
the qef gui, redirecting the outputs to diagnostic files that can be
viewed using the build monitor.
go appends messages to
/.qtree/goes/<host>/gomsgs when a command is
executed and when it terminates. goes can be used to remove
lines for completed jobs from the
/.qtree/goes/<host>/gomsgs files.
See also: go(1) go(-x) g goes
/.qtree/goes/<host>
^^ goes view or remove jobs from go message files
go, josh, and jog append messages to
/.qtree/goes/<host>/gomsgs
when ever a job is dispatched and when it ends. The following are
examples of such records:
pid command
host - directory yyyy/mm/dd hh:mm:ss
pid:status command
host - directory yyyy/mm/dd hh:mm:ss
pid! command
host - directory yyyy/mm/dd hh:mm:ss
pid:status! command
host - directory yyyy/mm/dd hh:mm:ss
The `:status' fields indicate that the job has completed, the `!'
that the job has been canceled. For completed jobs, the command
and directory fields may be truncated so that the entire line
fits into 80 characters.
goes can be used to:
+ view job records for current, specified, or all hosts;
+ cancel job records (i.e., insert a `!' after the pid:status field)
for completed jobs or jobs over a day old [*];
+ remove job records for completed or day old jobs [*].
[*] Can be applied to the current host's (default), a specified host's,
or all hosts' gomsgs files.
Note: jog might not be available.
See also: goes(1) goes(-x) go josh gomonitor jog(1)
/.qtree/goes/<host>/gomsgs
^^ gomonitor display josh halt files as updated and other files
gomonitor monitors the
/.qtree/goes/<host>/gomsgs files, displaying
job records that are appended to those files by go and josh.
Lines for completed lines are displayed in reverse video.
gomonitor also outputs the date and time (updated every five seconds),
the number of messages in your mailbox, the contents of
/.qtree/goshow
(if non-empty) or the contents of
/.qtree/td (see td(1)) and the
diary entries for the next week (see diary(1)).
gomonitor is designed to be run continuously in an xterm window,
refreshing the date and time every five seconds and the other
contents when they are changed. The command:
goes -c -h
may be used to cancel completed commands, for all hosts, which will
suppress their display by gomonitor.
Note: td(1) and diary(1) may not be part of your system.
See also: gomonitor(1) gomonitor(-x) josh g goes
^^ gotstr output names of files that contain argument string
gotstr outputs the list of files named in filelist arguments (defaults
to the standard input) that contain the argument string, and it does so
very quickly by using a Boyer/Moore algorithm and reading 32K at a time.
Frequently gotstr is used to prepare an argument list for grep(1) as in:
grep pattern `gotstr string filelist`
or better:
gotstr string filelist | rep -F pattern
See also: gotstr(1) gotstr(-x) rep bm(1)
^^ grpsort sort groups of lines specified by ranges
grpsort reads its input files, searching for lines that match the
specified argument regular expression. The matched line and the lines
that follow up to (but not including) the next matched line constitute
a group. All lines are copied to a temporary file and the matched
string and the offset to its group are saved. Once all the input has
been read, the matched string are sorted. Then the groups are read
from the saved input in the sorted order and output.
Note: If the pattern contains a sub-pattern -- specified by `\(...\)'
the string matched by the sub-pattern is used as the sort key.
As an example of its uses, grpsort is used to sort x_db entries, each
of which begins with `%{' optionally followed by a `-' and white
space. Thus to sort the entries of an x_db database by the first
key of a line one uses:
grpsort '^%{<-|>[ ]*\(.*\)'
See also: grpsort(1) grpsort(-x)
^^ hhmmss output a banner of the time
hhmmss clears the screen and outputs a banner of the time as in:
# ####### # # ####### # ### #####
## # # ### # # # ### # # # #
# # # # # # # # # # # #
# # # # ###### # # ######
# # # ####### # # # # #
# # ### # # # ### # # # #
##### # # # ##### # ### #####
Note that this representation of the time is legible when using the
``tiny'' or ``unreadable'' xterm fonts.
By default, the display is refreshed every ten seconds on the ten
second time. An interrupt (usually Ctrl-C) will cause the time to
be refreshed every second and a subsequent interrupt will revert to
refreshing on the ten second mark.
To terminate the clock use two interrupts within a second.
See also: hhmmss(1) hhmmss(-x) xclock(1)
^^ howto output selected howto information
When howto is invoked with an argument X, it searches for a file called
Howto.dir/X in the directories named by $PATH. If such a file is found
and it begins with the sequence `#HT' followed by a tab, the file
is copied to the standard output, after replacing certain `%'
sequences with run-time values (e.g., the date or user's name) or
interpretations.
howto is used to describe various procedures and/or standards.
If howto is invoked without arguments, it outputs a list of all the
howto files available.
howto is a link to bp.
See also: howto(1) howto(-x) bp
^^ incls dynamic dependency tracker
incls takes as input a list of files and outputs the implied
dependencies. One of its primary purposes are to maintain the incls._
database and to produce the dependency list used within the qef
scripts.
incls uses finite state automatas stored in files produced by
mkdeps to the argument files.
The qvrs variable SrcProdMap[class] may be used to extend the
list of affixes and their dependencies as generated by the -M
and -m flags.
See also: incls(1) incls(-x) mkdeps incls._ dmpdeps depsmap
SrcProdMap
^^ instal paranoidly install a file and audit it
instal [sic] is used to install files in remote directories. instal
accepts flags from the qvrs variables @_F_instal and @_F_instal[root] as
well as on the command line. It maintains an audit trail in the trail
named by qvrs variable @InstLog. instal works hard to check that
everything happened correctly.
Of particular importance is the -I flag which causes instal to not
fail if it cannot set the specified mode, owner and/or group. In such
an instance, instal outputs a noisy warning message and records the
failure in file named by appending `.fix' to @InstLog (after removing
`.log' if it exists). The failure is recorded in the format read by
tchown which can be used by a privileged user at the end of the
build. This feature means that one does not need to be root to build
installations!!
So why's instal misspelt? See faq8.
See also: instal(1) instal(-x) _F_instal(x-qvrs) InstLog(x-qvrs) tchown
^^ instdir install a directory
instdir is a link to instal that creates directories.
See also: instdir(1) instdir(-x) instal
^^ instfls install files, but only if necessary, according to script
instfls reads its input script which contains a number of
source/destination path name pairs. It installs the source files into
the destination files, but only after checking to ensure that the
installation will result in a significant change. A history file is
maintained to suppress file comparisons if the files have not changed
since the last time instfls was run.
instfls can also take a list of files and the names of the source and
destination directories.
See also: instfls(1) instfls(-x) instfls(x-qsg) instal
if_install._ih if_install._il
^^ josh a job shell
josh is a command interpreter that manages jobs selected by name
from the specified josh file -- defaults to
/.qtree/josh.
A josh file consists of lines of the following form:
# comments say no more
X=value assign a value to variable X
group
pats ... specifies that `group' implies jobs
matched by specified patterns.
labels...: commands the jobs to be done; commands may
be continued over multiple lines
and incorporate variable values
and command line arguments.
josh selects jobs to be done by those labels or groups matched by
command line specified patterns. The associated commands are then
interpreted using the shell. Flags are provided to detach the job
redirecting the output as is done by go in which case josh
maintains a josh halt file that records progress and can be used
to halt a josh job.
extremely important task performed by josh is to facilitate remote
executions of qef jobs as described in Remote-Qefs.
See also: josh(1) josh(-x) gomonitor go g Remote-Qefs
^^ kdbm extract from or add to dbm database
kdbm is a tool used to create, update and query a dbm database.
Basically a kdbm database uses ASCII keys with single or multiple
text line data elements.
See also: kdbm(1) kdbm(-x) ldbm sdba
^^ l list files in columns
l is yet another ls(1) type program that lists entries in the
specified directories. It is provided as part of the Q-Tree
to ensure a consistent interface and provide additional
capabilities not normally available using ls.
lc is a link to l that implies the -a and -l flags -- list all files
(-a) by file-type (-l).
Note: Some man(1) commands cannot retrieve l(1) due to their
interpretation of `l' as being a section number. In
such a case see lc(1).
See also: l(1) l(-x) lc lc(1)
^^ lash long argument list shell interface
lash runs its argument command repetitively for the specified
arguments -- possibly read from the standard input. The command
should contain % character sequences to specify the positions and
forms of the arguments. Supported forms include selecting the
argument's directory, basename, root, etc.
A command may also use multiple arguments.
lash is similar to the BSD tool apply.
See also: lash(1) lash(-x)
^^ lc list files by type in columns
lc is a link to l that lists the files in the argument directory
by type (e.g., directories, devices, etc). It also lists all
files whereas l suppresses files whose names begin with a `.'.
See also: lc(1) lc(-x) l
^^ ldbm extract from or add to dbm line database
ldbm is used to create, update and query an ldbm database. which
is a dbm database (i.e., X.{dir,pag} pair) in which a key's data
item (as stored in the X.pag file) is a list of seek offsets into
third file X.data. The offsets point to newline terminated lines
of text for the key.
See also: ldbm(1) ldbm(-x) kdbm sdba
^^ libs output information on libraries used by the named files
libs processes a list of symbolic library names given via arguments
or the libraries specified for an argument file via the LIBS[]
variable or as embedded in the files themselves as in:
/* LIBS: -ldtree
By default, libs outputs the library names or symbols that will be
used when linking the named file or library. Flags may be specified
to show the raw library list (-r), the list after LibMap expansion
is done (-m), the expanded list after the library search is done (-e)
the list of symbols to be used when linking (-c), and list all
libraries that match a specified symbol (-A).
Try:
libs -aA -lc
Note: If a libs argument begins with [name], as in:
libs [alternative]/.../realfilename.c
then alternative is used to match LibStatic[] patterns, instead
of realfilename.
Note: The qvrs -l flag outputs a list of all the variables used
in library searches and their current settings.
See also: libs(1) libs(-x) *lib-macros(x-qefpp) *lib-vars(x-qvrs)
Apropos: ? -Q <Lib|archive|libs>
^^ lines print first N and last M lines
lines prints the first head (default 5) and the last tail
(default 0) lines of each argument file (defaults to the standard
input) or the files named by the files or the standard input if the
-f flag is specified. lines also supports a -r flag which
causes lines to output lines in the rpl format, for example:
file:000123:contents of line # 123 in file
See also: lines(1) lines(-x) rpl
^^ linked list files with multiple links
linked checks the argument files (defaults to files named in the
standard input) or the files named by the argument files (if -f)
for files that exist and have multiple links. If there are 1 or less
links nothing is output, otherwise the name of the file is output.
A flag (-s) is provided that output those files that are symbolic
links.
See also: linked(1)
^^ lls ls for input files with selected fields output
lls is yet another variant of ls(1), with the difference that
the files to be listed may be named by the standard input or the
argument files and the file attribute fields displayed are
selectable by a command line option (see -o).
The list of selectable fields is output by lls(-x) and given in lls(1).
See also: lls(1) lls(-x) rls
^^ manprep prepare manual sections for qef info tool
manprep is used to transform output of man(1) into the form required
for presentation by the qef graphical user interface. The output
consists of Tcl/Tk expressions specifying bold text, section headers,
and references to other manual sections.
See also: manprep(1) manprep(-x)
^^ mimk issue updating commands according to a dependency script
Yet another make(1), but built specifically to be a suitable back-end
for qef. mimk duplicates most of the important functionality of make,
but does not support variables or suffix rules as such things are done
in other qef processes. mimk will run processes in parallel and will
rerun constructions if the dependency list or the constructions itself
has been changed since its last execution.
See also: mimk(1) mimk(-x) qhy qmkhist._
^^ mkalltraits run mktraits on remote hosts
Without any flags or host arguments, mkalltraits runs:
qremote -h <host> mktraits -u
for all hosts <host> for which the variable <host>.qtree exists in the
qdsrv database. The mktraits will rebuild the <Q>/data/traits/<host>.tab.
This is usually necessary after <Q>/lib/traits.vrs or <Q>/data/traits.ext
files are changed and the traits binary files stored in traits/<host>.tab
files need to be rebuilt.
The -r flag specifies that rsh(1) is to be used instead of qremote as
might be required when qremote cannot be run due to a missing traits
file.
See also: mkalltraits(1) mkalltraits(-x) traits qremote qdsrv
^^ mkddt create ddt declaration
mkddt transforms its argument input files into a C header or source
file (if -c) containing appropriate initializations for Ddt_t
structures used to control the Dynamic debugging trace (ddt) package.
mkddt is used to build qef itself and a number of other Q-Tree
packages. It is not intended for general use at this time. As such
it might not be available.
See also: mkddt(1) mkddt(-x)
^^ mkdeps compile deps scanner file
mkdeps compiles a description and control variables of the scanner
used to process files to extract embedded dependencies such as the
`#include' statements of C.
The resulting object file is used by various programs (e.g., incls)
to extract embedded dependencies from a source file. Such files are
usually stored in <qtree-root>/lib/deps.
dmpdeps may be used to examine and/or test a mkdeps object or an
installed version.
depsmap is used to create a file that maps from file suffixes to
mkdeps object files.
Warning: The mkdeps language is obtuse and baroque. It is not
intended for the casual user. If you need a new language
supported, write to support@qef.com and it will be created.
See also: mkdeps(1) mkdeps(-x) incls dmpdeps depsmap
^^ mkopts create options header file
mkopts creates a C language header file of defines for options. It is
used to create header files based on qvrs option settings.
A qsg library script (mkopts(x-qsg) exists to create header files
using mkopts.
See also: mkopts(1) mkopts(-x) mkopts(x-qsg)
^^ mkqtree set up new qef tree
mkqtree creates a new qef shadow tree for the current directory.
Given the command:
mkqtree -t@TreeType directory subtrees ...
mkqtree performs the following:
mkdir directory # if directory does not exist
cd directory
rootvrs -tTreeType original-directory # if no root.vrs
confvrs -c # if conf.vrs does not exist
treedirs subtrees ... # if subtrees not .
The above creates the new directory, creates the root.vrs file linking
the new directory to the original, copies confvrs/confdefl.vrs to
conf.vrs and populates the tree with the requested sub-directories.
See also: mkqtree(1) mkqtree(-x) rootvrs confvrs treedirs confdefl.vrs
^^ mkquete produce manual section index
mkquete processes manual sections to extract the short description
in the NAME section and to build output records in the following form:
section name <tab> description
Flags or the traits variables ManSections and ManZipSuffixes name the
manual sections to be processed and the suffixes for compressed
files respectively.
mkquete is run to produce <qtree-root>/data/quete/*.db which is read by
quete to create a manual section topic list within the help information
window in qefgui. See QueteDbs(x-qefgui).
See also: mkquete(1) mkquete(-x) man(1) traits data/quete quete.db-maint
^^ mksolib create shared library externs list
mksolib is used to convert a list of variables and their types into
a C module which can then be linked with a library to create a
shared object (i.e., so) library.
Basically to create a shared library, a mksolib input file is created
that lists at least one variable from every required module in the
archive. When such a file is processed by mksolib, and then compiled
and linked with the standard object library (with the appropriate
flags), a shared library containing the defining modules for each
of the listed variables is created.
A qsg library script (mksolib(x-qsg)) exists to facilitate mksolib's use.
See also: mksolib(1) mksolib(-x) mksolib(x-qsg)
^^ mktraits compile traits files
mktraits creates the traits database <Q>/data/traits/<host>.tab.
The traits database is a set of variable/value pairs used to store
system, host, and site settings such as capabilities, pathnames, and
special values such as QDSRV_HOST.
mktraits compiles the traits source files traits.vrs and traits.ext.
These language used in these files is identical to that of qvrs,
except that the trait(x-qvrs) function is not supported.
Note: Whenever mktraits -Ru is run, any traits/<host>.tab file
that is older than either of the source files is removed.
Running traits or any query of the traits database via the
libdtree.a A.P.I. will recreate the file if necessary.
See also: mktraits(1) mktraits(-x) traits trait(x-qvrs)
^^ mkvernum create or change version string
mkvernum extracts the current module version number from the qvrs
variable Revision[module] or Revision and generates a version string
for embedding in the code or library. Many of the qsg scripts
support a -v flag that will automatically create, compile and add
the version string to a program or library.
One of the important mkvernum features is its ability to embed the
value of a counter that is incremented on each use in the output
string. These counters are retrieved by communicating to qdsrv
which maintains <Q>/data/mkvernum.db.
Note: vcc is a link to mkvernum used to create and compile a
C version file.
See also: mkvernum(1) mkvernum(-x) vcc qdsrv vernumcomp verlib/
<Q>/data/mkvernum.db Revision(x-qvrs) _F_mkvernum_cc(x-qvrs)
ReportMkvernum MkvernumFormat MkvernumPath RevisionString
^^ mnfadd add a new manifest to manifest database
mnfadd is part of the manifest package -- see mnfdb. mnfadd adds a
new input manifest to a manifest database and outputs the result.
See also: mnfadd(1) mnfadd(-x) mnfdb manifest(x-qmisc)
^^ mnfchk check manifest database for syntax and consistency
mnfchk is part of the manifest package -- see mnfdb.
mnfchk reads the argument manifest database -- defaults to the
standard input -- outputting any syntax errors in the manifest
database to an argument file -- defaults to the standard output. If
the -S flag is specified, for all files/version tuples in the selected
releases (defaults to all), mnfchk finds the associated s-file and
checks that the named version actually exists.
See mnfchk(1) for a list and explanation of the errors that can
be output.
Note: The -S check works with SCCS files only. To check a manifest
for some other system, use mnfput -m to retrieve the files
and associated versions and input that information to a mechanism
that checks the validity of the file/version tuples.
See also: mnfchk(1) mnfchk(-x) mnfdb manifest(x-qmisc)
^^ mnfcmp compare two manifests
mnfcmp is part of the manifest package -- see mnfdb.
mnfcmp compares two manifests reporting the differences in three tab
separated fields giving the file name, the versions of that file in
the first and the second manifests. If a file is not listed in either
one or the other manifests the associated version field is output as a
single caret (`^').
See also: mnfcmp(1) mnfcmp(-x) mnfdb manifest(x-qmisc)
^^ mnfdb output manifest database release information
mnfdb outputs the release information for the releases selected by
the -r flags (defaults to -r \*) in the named manifest database.
mnfdb is part of the manifest package which consists of the following
tools:
mnfadd add a new manifest to manifest database
mnfchk check manifest database for syntax and consistency
mnfcmp compare two manifests
mnfdb output manifest database release information
mnfdel delete releases from manifest database
mnfput output a manifest or manifest database
See mandb(1) for descriptions of manifests, manifest databases,
releases, and the care and feeding of manifest databases.
See also: mnfdb(1) mnfdb(-x) manifest(x-qmisc)
^^ mnfdel delete releases from manifest database
mnfdel is part of the manifest package -- see mnfdb.
mnfdel is used to remove a named release or releases from a manifest
database. The associated release declarations are removed as are all
bindings of file/version tuples to those releases. The resulting
manifest data is output to a named file or the standard output.
See also: mnfdel(1) mnfdel(-x) mnfdb manifest(x-qmisc)
^^ mnfput output a manifest or manifest database
mnfput is part of the manifest package -- see mnfdb.
mnfput reads the selected manifest database and outputs the named
releases. The -m flag outputs a resolved manifest. If multiple
releases are selected and those releases specify differing versions
for a specific file, the version specified by the youngest selected
release is output.
See also: mnfput(1) mnfput(-x) mnfdb manifest(x-qmisc)
^^ necho echo with escape interpretation
necho just echos its arguments, much the same as echo(1).
However, necho provides special character interpretation in its
arguments to facilitate specification of non-printable characters,
such as "\r", "^M", or "\15" for carriage return.
necho also provides output redirection via arguments, which may
be necessary to ensure correct interpretation or alternatively
eliminate the need to invoke a shell.
See also: necho(-x) necho(1) echo(1)
^^ numb produce numbered lines
numb reads lines from the argument files (defaults to the standard
input) and outputs the line with a line number.
An option (-f) exists to allow the specification of the output format.
See also: numb(1) numb(-x)
^^ pa output, list, or delete cut files
pa and its companion tool ct paste and cut files. When ct is
invoked it copies its input into a file in the user's $CTDIR
(default
/.qtree/ctdir) directory. The name of the new file is
`,' followed by two decimal digits.
pa can be used to list, examine, retrieve and/or remove cut
files by relative age or explicit index.
The default command is to cat the most recently modified file
in the $CTDIR directory.
See also: pa(1) pa(-x) ct $CTDIR
/.qtree/ctdir
^^ pathclash produce list of duplicated executables in path
pathclash outputs the file names that occur in more than one of the
directories named by $PATH, in other words, the path name clashes.
It is provided to facilitate quickly determining if any of the qef
tools clash with existing tools in the user's $PATH.
See also: pathclash(1) pathclash(-x)
^^ pathto map argument file to special directory
pathto maps its argument files by replacing symbolic prefixes
to real pathnames. The symbolic names are listed by the -l flag.
pathto is used in shell scripts to facilitate specification of
Q-Tree (and other) files by applying the appropriate substitution
and search mechanisms.
pathto may be used to determine the default <qtree-root> using:
pathto -d qt
Note: Additional symbolic mappings can be specified in the
roots.map files.
See also: pathto(1) pathto(-x) QTREE <qtree-root> roots.map
^^ pdirs directory stack manipulation for shells without pushd
pdirs is provided for use on systems that lack that very useful function
pushd. pdirs should not be used directly as its purpose is to
deliver an argument for a chdir and to maintain a list of directories
which must be done using built-in shell functions. To use pdirs,
one should use:
% eval `qfunc pdirs`
which defines the following functions:
pd () { eval `pdirs -e $* ++ $_dirs` ; }
pushd () { eval `pdirs -e $* ++ $_dirs` ; }
popd () { eval `pdirs -ep $* ++ $_dirs` ; }
dirs () { echo `pwd` $_dirs ; }
The resulting functions pushd, popd, and dirs provide much the
same functionality as their csh name-sakes.
See also: pdirs(1) pdirs(-x) sh(1)
^^ putifdif copy input to output file if different
putifdif compares its standard input to contents of its argument file,
copying the input to the argument file if they differ.
putifdif is used to process configured header files, changing the
installed copy only if its contents would change.
See also: putifdif(1) putifdif(-x) cpifdif
^^ qconfset add variable setting to the conf.vrs file
qconfset is provided to insert or replace a variable setting or an
option at the beginning of the current tree's conf.vrs file, if there
is one. The conf.vrs is the qvrs file used to specify users options
and controls. It is typically initialized using confvrs which copies
the default configuration file confvrs/confdefl.vrs.
See also: qconfset(1) qconfset(-x)
^^ qd shell alias/function to chdir using selected qdsrv database entry
To facilitate changing directories within the shell one sets the following
alias or function:
alias qd 'set qdtmp=`qds -d \!*` && cd $qdtmp' # in csh
qd () {
qdtmp=$(qds -d $*) && cd $qdtmp
} # in sh, ksh or bash
The above are also output by the qds -X flag and qfunc qd. To define
qd one uses:
eval `qfunc -c qd` # in csh
eval `qfunc qd` # otherwise
Once set, one can use qd to chdir to trees or sub-directories within
a tree using queries, absolute indices, or qds flags such as -n
or -i.
Note that an argument to qd may be used to specify the sub-directory
of the target tree. If the target tree is the same project as the current
tree, the qd will chdir to the same sub-directory of the target tree.
To specify the root of the tree, on should begin the argument with a
slash as in:
qd <qds flags> /sub-dir
See also: qds qfunc
^^ qdchk check host's qdsrv database entries
qdchk retrieves all the paths for the current host from the qdsrv
database -- see qdsrv(1). For each retrieved path entry, qdchk
checks the fields and directories for validity reporting any
discrepancies.
The error and warning messages produced by qdchk are explained in
individual items of x-qmisc. See *qdchk(x-qmisc).
See also: qdchk(1) qdchk(-x) qdsrv qdsrv-record *qdchk(x-qmisc)
^^ qdid assign qdsrv ident and/or bind to path
qdid provides support for retrieving an unused qdsrv identifier and/or
binding a qdsrv identifier to a qdsrv database entry.
Once an identifier is bound to a path, qds -i may be used to retrieve
that path. Thus a user may identify a path that represents the current
set of working directories.
The environment variable $QDSRV_ID may be used to contain the identifier.
If QDSRV_ID is not set the lowest identifier assigned to the user.
Note: qds also has an option to do the path binding.
See also: qdid(1) qdid(-x) qdsrv qds $QDSRV_ID
^^ qdmgt general qdsrv management interface
qdmgt provides a generalized message interface to qdsrv. It sends
argument message (possible specified by a flag) to the server and then
just writes the returned messages to the standard error output (if the
returned message begins with a `!') or to the standard output.
qdmgt was developed initially to test the server prior to the
existence of the specialized tools. As such all the qdsrv services
may be invoked via qdmgt and some are available only by using it.
The list of messages supported by qdsrv is produced by the command:
qdsrv -X
Note: To edit the database one must:
qdmgt -v # check that server running and get db name
qdmgt -f # freeze the database
edit <dbfile>
qdmgt -r # reread the database and unfreeze it
See also: qdmgt(1) qdmgt(-x) qdsrv qds qdchk
^^ qds select and print entries from qdsrv database
qds retrieves paths from the qdsrv database. Flags can specify attributes
(e.g., project, release, host) of the paths to be retrieved.
The primary purpose of qds is to provide the argument to a chdir command.
The -d flag specifies that a single path must be selected. If a single
path is matched, the matching paths are output.
qds is used in the qd function or alias to facilitate chdiring
using queries or path indices.
See also: qd qds(1) qds(-x) qdsrv qdmgt qfunc
^^ qdsrv qef project database server
The qdsrv database, usually contained in <qtree-root>/data/qdsrv.db
contains information about qef administered trees. qdsrv is a
server program that provides facilities:
* to change, create, or delete path database entries
* to reserve, set and retrieve qdsrv identifiers used to anchor a
user's session to a particular path
* to freeze (prohibit changes) or reload the database
* to retrieve the version and process information of the running
server
* to manage the licences
* to halt the server
* to retrieve the time on the server's host
qdsrv should be run on a host on the local network. The host on
which it runs and its port number are named by the traits QDSRV_HOST
and QDSRV_PORT -- see traits(1).
Note: The uid of the qdsrv process must be the owner of the
database. Thus the qdsrv executable should be setuid
to the owner of the database.
See also: qdsrv(1) qdsrv(-x) qdsrv.db qdsrv.log mkvernum.db qds
qdmgt qdid qdchk traits QDSRV_HOST QDSRV_PORT ? qdsrv
qliceadd qlicedmp
^^ qdupd add path to qdsrv database
qdupd is used to add or change a path and its corresponding parameters
to the qdsrv database (usually stored in <qtree-root>/data/qdsrv.db).
See qdsrv(1) for a description of the fields of the database and their
use.
Note: rootvrs invokes qdupd to add or correct paths when a new
root.vrs file is created or changed.
See also: qdupd(1) qdupd(-x) qdsrv rootvrs qdsrv.db
^^ qef the driver
qef is the user interface and driver for the system. Consists of three
major phases:
1) Configuration
2) Script preparation
3) Script Interpretation
1) The first phase consists of initialization and various validity
checks (see ForbidQef), output of the header line, etc., but the
most important aspect is to run qvrs to compile the qvrs-files
into a database that is saved in /tmp/qv_*.tmp for consultation
by qef and other tools.
2) Every directory in which qef is to be run must have an associated
qeffile (or a qeffile2), which is found by searching the @SrcPath
directories or as named by QefFile[@RealBranch]. This file must
contain a Begin line. This line plus other qvrs settings are used to
determine how the back-end input script is to be prepared. Usually this
is one of the following:
* run qefdirs to convert qeffile to a script which is processed
by qefpp to produce a mimk(1) file that handles constructions
across multiple directories; or
* run sls to produce a list (srclist._) of the source files
for the current directory and then invoke qsg to transform that
list and the contents of the qeffile into qefpp input which
will produce input to the back-end.
Other variations are possible, but the above two represent over 95%
of qeffiles.
3) Invoke the back-end as named by _BackEnd_ to interpret the script
prepared or selected by the second stage. In most instances the
backend will be one of mimk, qsh, or make. Once the back-end
has completed, qef performs a number of clean-ups (e.g., removing
its temporary files), outputs the trailer line and exits.
The manual section qef(1) gives a more complete description of the
processing. Also see the few hundred other sections in this database,
the user guide, and other documentation.
For an introduction, the tutorials, and the introductory seminar, see:
qef-intro(x-qef) -- introduction to qef
seminar(x-qmisc) -- An introduction to QEF seminar slide set
qef-tuts(x-qmisc) -- command line and GUI tutorials
See also: qef(1) qef(-x) qvrs qsg qefdirs
^^ qefdirs qef script generator for multiple directories
qefdirs is one of the two major script generators of the qef system.
It processes a simple list of directories and a list of their
constructions and create a qef/mimk script that provides facilities to
invoke constructions by group (e.g., Local, Install, Man), or by
individual directories (e.g., cmd
I, man
M).
It also supports division of the directory list into different levels
that can be invoked individually or in ranges.
Note: The input syntax is described by qefdirs's -X flag.
See also: qefdirs-intro x-qefdirs(x-qefdirs) qefdirs(1) qefdirs(-x)
qefdirs.qh(x-qef) TreeList(x-qvrs) multidir-qef(x-qefeg)
^^ qefgui run the qef qui
qefgui is a Tcl/Tk application that provides facilities to: navigate
project trees; invoke qef and other tools; access the qef documentation
(such as this); interface with the versioning system, create, delete
and modify files; and create, delete and modify project trees.
See also: qefgui(1) qefgui(-x) x-qefgui qefgui-intro
^^ qefinfo run the qef info tool
qefinfo is just the qefgui program, but limited to the Qef-Info-Tool
window. It is provided for use on systems for which qefgui is not
provided.
See also: qefgui
^^ qefpp the qef macro processor
qefpp is not a separate program. Rather it is a subroutine of qef
itself which preprocesses scripts much like cpp in the C compiler.
Even though qefpp is not a tool, as an important phase of the qef
process it is given an external identity, an albeit brief entry
in this tool database, and its own x_db database x-qefpp.
See also: qefpp(x-qefpp) x-qefpp(x-qefpp)
^^ qefsort sort or merge text files
qefsort is equivalent to the normal sort program provided by most
systems. However, it is provided to circumvent bugs in some versions.
qefsort is provided on windows systems as that system does not provide
sort itself.
It is provided on systems that use a GNU version of sort to circumvent
the damaged semantics of the -o flag.
See also: qefsort(1) qefsort(-x)
^^ qenv output environment variables in sorted usable form
qenv without any arguments, outputs the entire list of
environment variables as a series of `=' statements.
Alternatively the -c flag can be used to specify that the csh
format is to be used.
If arguments are specified, they should name environment variables
to be output.
Note: qenv duplicates some of the functionality of the AT&T env
and the BSD printenv, but qenv is consistent and
provides the ability to select individual variables.
See also: qenv(1) qenv(-x) env(1) printenv(1)
^^ qfunc output selected qfunc function/alias file
qfunc is yet another bp link. When invoked with an argument X,
qfunc searches for a file called Qfunc.dir/X in the directories
named by $PATH. If found and the first four characters of the file
are `#QF' followed by a tab, the file is copied to the standard output
after replacing certain `..' sequences by special run-time values.
qfunc was implemented to facilitate the setting of useful csh and sh
aliases or functions. For example, the command:
qfunc qd
outputs:
qd () {
qdtmp=$(qds -d $*) && cd $qdtmp
} # in sh, ksh or bash
which is the definition of a shell function `qd' which facilitates
chdiring to directories retrieved from the qdsrv using the qds
interface. To perform the definition within the current shell one
would use:
eval $(qfunc qd)
Note that:
qfunc -c qd
delivers the equivalent alias for csh. If qfunc is invoked without
arguments, it outputs a list of the available qfunc files and their
brief descriptions.
Currently the provided functions are:
Ev function to invoke envset for selected set
Qf function to eval qfunc for selected function
cats function to invoke cat on file(s) found using sls
eds function to invoke $EDITOR on file(s) found using sls
pdirs pushd and popd implemented with pdirs
qd function to chdir using qds selection
qdp function to pushd using qds selection
qdpush function to pushd using qds selection
See also: qfunc(1) qfunc(-x) bp howto
^^ qgdiff graphical file difference viewer
qgdiff presents the differences between two argument files -- as
determined by diff -- graphically. The two files are displayed
side by side showing the changes, deletions and insertions
in coloured segments.
See also: qgdiff(1) qgdiff(-x) diff(1)
^^ qhy report why a target was rebuilt
qhy examines the mimk history file qmkhist._ and outputs selected
information concerning the argument files, such as the time and
the reason it was last re-built. A flag (-r) specifies that qhy
is to recurse through files that forced the rebuild. Another flag
(-d) will list all the files on which a file depended and give
their current times.
Note: qhy reports only that information available in the qmkhist._
file or by examining the file system to retrieve current
times for relevant files. The information it reports, such
as the dependency list may have since been changed.
See also: mimk qmkhist._
^^ qlex interface to lex
qlex is an interface to lex that moves lex.tab.c to appropriate
location and optionally converts `yy' variables.
The qlex flags for file.l are specified by the qvrs variable
_F_lex[file.l] (see _F_*).
The actual program to be run is specified by _T_lex(x-qvrs).
See also: qlex(1) qlex(-x) qyacc
^^ qliceadd add licences to a licences database
qliceadd adds new licences to the licence file -- defaults to
<Q>/data/licences.db. The argument keys are provided by the QEF
supplier. To generate this key the supplier must be provided with
the current database's header record and count, which can be
retrieved using the command:
qlicedmp -k file
or
qdmgt lickey
The supplier will combine this key and your requests for licences to
generate the keys to be used as key arguments to qliceadd.
These keys, assumedly returned by e-mail, should be specified as
arguments to qliceadd to add the requested licences to the database.
Then:
qdmgt licread
is run to force qdsrv to reread the licence datbase.
Alternatively the licences may be added via the server using:
qliceadd -s keys ...
qdmgt licadd keys ...
To check the licences current held by qdsrv, run:
qdmgt liclist
See also: qliceadd(1) qliceadd(-x) qlicedmp qdsrv qdmgt
^^ qlicedmp dump licences database
qlicedmp outputs information about the argument QEF licence files
-- defaults to <Q>/data/licences.db. The standard output will look
similar to:
Header: ad2000031, 7 nodes
System (unlimited):
linux2
winnt4
System:
sun5
irix6
Licences:
bb0000001
bb0000002
Demo licences, expires:
2000/04/01 (za2000091)
which shows the database has unlimited licences for Linux2 and WindowNt4
systems, and two regular and one demo licence (until April 1st)
for use on Sun5 and Irix6 systems.
To check the licences current held by qdsrv, run:
qdmgt liclist
See also: qlicedmp(1) qlicedmp(-x) qliceadd
^^ qmsdev Microsoft Developer's Studio project file generator
qmsdev process the qvrs files to produce the proj.dsp, proj.dsw,
and a command file runqef.bat.
These files are required used by the Microsoft Visual Studio integrated
development environment. For details on how to use this command, see
qmsdev(1)
See also: qmsdev(1) qmsdev(-x)
^^ qmsg send a message or mail to designated users
qmsg sends a single line message specified by either arguments or
read from the standard input to the specified users. The message
is sent to the user's terminals (if they are logged in) or as mail.
Flags are provided force mail to be sent.
qmsg is provided as part of the Q-Tree product as it is used by go to
report that a job has completed.
See also: qmsg(1) qmsg(-x) go josh
^^ qremote run a command on a remote host (if necessary)
qremote is used to run commands remotely, if necessary. Basically
qremote creates and executes a shell command that executes the argument
command on the appropriate host after the necessary setup (e.g., the
setting of $QTREE and $PATH. If the command is to be run locally,
qremote will execute:
<Host-Q-Tree>/bin/cush -Q -E env-set \
-d dir [ go -d ] command ...
If the command is to be run remotely, qremote will execute:
<remote-sh> host <Host-Q-Tree>/bin/cush -Q -E env-set \
-r dir [ go -d ] command ...
<remote-sh> will be
/.qtree/qremote/<host>, <Q>/data/qremote/<host>,
or rsh(1), rcmd(1), or remsh(1) (whichever is provided).
<Host-Q-Tree>: the location of the target hosts's <qtree-root>, as
named by -q argument, the qdsrv variable <host>.qtree,
or /usr/qtree.
-E env-set: The named envset should set $PATH, $QTREE and
other necessary environment variables. The envset can
be specified via qremote's -E flag or @QremoteEnv.
The default is "qremote".
See also: qremote(1) qremote(-x) BuildHost(x-qvrs) QremoteEnv(x-qvrs)
Remote-Qefs envset
^^ qsg the primary qef script generator
qsg is the primary qef script generator -- see qsg-intro(x-qsg). Its
major purpose is to convert simple statements of intent into the
input to the specified backend. Extensive documentation of the
syntax, semantics and available qsg script may be accessed using x-qsg.
Note: The default input to qsg is the contents of the directory's
qeffile following the Begin line.
See also: qsg-intro qsg(1) qsg(-x) x-qsg(x-qsg) x-qsg(x-qef) qef
qsgcomp qsgdump
^^ qsgcomp compiles a qsg script to object
qsgcomp compiles a qsg script to a p-code representation. qsgcomp
is usually used only to create qsg object files for inclusion in
a qsg library such as the default library std.qsl.
See also: qsgcomp(1) qsgcomp(-x) qsg qsgdump std.qsl(x-qsg)
x-qsg(x-qsg)
^^ qsgdump dump a qsg object file
qsgdump is a debugging and documentation aid for the qsg script
programmer and user. Options exist to dump a qsg script's object
code, summary, strings, header, or source.
Note: The standard library std.qsl is searched for the argument
files before checking for a file, hence:
qsgdump -S hanoi
will output the source for the hanoi script.
Also note that qsgdump will compile its argument files if they
are not qsg object files.
See also: qsgdump(1) qsgdump(-x)
^^ qsh qef shell command interpreter
qsh is yet another shell command interpreter specifically provided to
execute shell scripts generated by qef script interpreters such as
qsg. For some directories, such as the file system integrity check
directory, qsh will serve as the backend interpreter instead of make,
mimk, or qmk.
qsh is used instead of sh as qsh provides a better echo facility, can
be made to ignore the exit status of selected commands, and checks
the $QEFHALTFILE file to determine if the qef session is being halted.
See also: qsh(1) qsh(-x)
^^ qtreeinf output information on $QTREE and its directories
qtreeinf outputs something similar to the following:
$QTREE: /p/qtree/8.3/linux2_0i
Default $QTREE: /usr/qtree
0: /p/qtree/8.3/linux2_0i
Real Dir: /p/qtree/8.3/linux2_0i
Qtree(full) 8.4(567) - Linux-2.0.34-i686(linux2_0i) - 2000/04/14
dt on gobo in /p/qtree/linux2_0i/o8.3
The first line is the current value of $QTREE.
The second line is the default value for $QTREE.
This is in turn followed by a set of lines for each directory named
by $QTREE. This consists of the directory index, the name used,
the real name of the directory, and the relinfo file contained
in that directory.
See also: qtreeinf(1) $QTREE relinfo
^^ quete list x_db topics and quete.db entries that match patterns
quete is a specialized search tool that searches the title lines
of all the x_db databases it can find (such as this one) and the
quete/*.db database (as built using mkquete) and outputs the
matched lines. One of the flags it supports is -t which causes
the output to be done as a Tcl/Tk list for direct loading into the
Topic window of the qefgui Info Tool window. The output includes
Tcl/Tk tags to allow direct loading of a listed topic by clicking
on the manual or x_db reference.
The Apropos button in the Info Tool window invokes quete. For
example try: ? manual.
quete supports the following flags that may be useful in queries:
-Q limit search to $QTREE manual sections
-X limit search to x_db databases
-M limit search to manual sections
-N Do Not do dual case pattern matching
-<num> limit output to <num> items
pattern ... patterns matched against lines -- Note if a
pattern contains ` & ', it is split into
multiple patterns.
Note: quete is a french noun for quest, search, collection,
and beating about.
See also: quete(1) quete(-x) x_db mkquete quete/*.db
Qef-Info-Tool(x-qefgui)
^^ qvrs process the qvrs files
qvrs is the major parameterization system of the qef system. Due to
its importance there is a x_db database dedicated to its description.
See qvrs-intro(x-qvrs).
qvrs is invoked by many of the qef tools to retrieve settings and
controls. It finds and processes the root.vrs, tree.vrs, qeffile
and leaf.vrs files for the current directory. The -p option writes
out a `compiled' list of all the settings.
To avoid repetitive execution of qvrs within a single qef run, qef
executes qvrs -p saving the output in a temporary file, the name of
which is assigned to the environment variable $QVRS_FILE. Any
program that needs qvrs settings checks this variable first, and if
set reads the named file directly. Otherwise, the tool invokes qvrs
-p and reads the output from the connecting pipe.
In the absence of any arguments or flags, qvrs outputs the current
settings.
See also: qvrs-intro(x-qvrs) qvrs(1) qvrs(-x) qef x-qvrs(x-qvrs)
x-qvrs(x-qef)
^^ qvrsdmp process qvrs binary file
qvrsdmp processes the output produced by qvrs when the -p flag is
specified. The file is read and the symbol table is written to the
standard output. The file to be processed is named explicitly by
argument, by $QVRS_FILE or by actually executing qvrs -p.
See also: qvrsdmp(1) qvrsdmp(-x) qvrs
^^ qvrsexpr evaluate and output qvrs expressions
qvrsdmp evaluates its argument expressions as qvrs expressions and
outputs the results, one line per argument.
This is equivalent to running qvrs with the same arguments, except
that if a -f qvfile parameter is specified or if $QVRS_FILE is
specified, the named file is taken to be the name of the qvrs binary
file as produced by qvrs. By directly loading the database from a
file, the file system searches and the interpretation of those files
done by qvrs -- which can be expensive -- are avoided.
qvrsexpr was created for use within the graphical user interface.
See also: qvrsexpr(1) qvrsexpr(-x) qvrs qvrsdmp
^^ qyacc interface to yacc
qyacc is an interface to yacc(1) that moves y.tab.c to appropriate
location and optionally converts `yy' variables.
qyacc was created to make processing yacc files a single command.
The qyacc flags for file.y are specified by the qvrs variable
_F_qyacc[file.y].
The actual program to be run is specified by _T_yacc(x-qvrs).
See also: qyacc(1) qyacc(-x) qlex _F_qyacc(x-qvrs) yacc(1)
^^ r90 reflect lines around diagonal
r90 reads the argument files (defaults to the standard input) and
outputs the result of reflecting the lines around the main diagonal.
This has the effect that the first output line consists of the first
characters of the input lines, the second output line consists of the
2nd character of each input line, and so on. Blanks are used where a
character is missing (i.e., the line corresponding to the position is
shorter than the maximum length line).
Flags are provided to: trim leading spaces and tabs on input (-l);
trim trailing spaces and tabs on input (-t); reverse input lines
after padding to same length (-r); pad output lines to the same
length (-p); trim trailing spaces on output (-T); and reverse
output lines (-R).
r90 has a number of interesting applications which are not easy with
the standard tools, such as:
r90 -pt | r90 # right pad to same length
r90 -rlpt | r90 -R # left pad to same length
r90 -ptR | r90 -T # reverse order of lines in file
r90 -rptl | r90 -R | r90 # create column headings
(r90 -p f1; echo; r90 -p f2) | r90 -T # join files together
The -X flag lists the above and how to use r90 to perform the eight
rotations and reflections that can be performed on an input file.
See also: r90(1) r90(-x)
^^ rc windows resource compiler
rc is a shell script provided by Interix that compiles windows
resource files. Further documentation may be available in the
//C/Interix/man.
See also: rc(1)
^^ rcslocks report the RCS locked files in a directory
rcslocks reads its argument directory -- defaults to RCS -- to find
and files of the form *,v. Any such files are read to detect any
locks. If any locks are found the name of the base file (i.e., the
file minus `RCS/' and the any `,v') is output. A -l flag exists to
specify that the locks themselves are to be listed.
See also: rcslocks(1) rcslocks(-x) co(1)
^^ recur execute a command repetitively
recur executes its argument command repetitively, sleeping num
(defaults to 3) seconds after each execution. If the -i iterations
was specified, recur terminates once the command has been executed
that many times. recur will also exit if -T (while true) flag was
specified and the command returned a non-zero exit status (i.e., false),
or if the -F (while false) flag was specified and the command returned
a zero exit status (i.e., true). Otherwise execution continues until
the program is interrupted.
One past use of recur was:
recur -T qdsrv
that is run qdsrv repetitively until it successfully started, which
it could not do until its port times out. qdsrv has since been
changed to have a -R flag that repetitively tries to connect to
the port until it succeeds.
See also: recur(1) recur(-x)
^^ rep another grep
rep is yet another version of grep(1). rep uses regular expressions
equivalent to that used many Q-Tree tools such as qsg and qvrs.
This version of regular expressions offers a number of features
not offered by other implementations -- see regexp(x-qmisc).
rep also supports a number of features not offered by other greps
such as multiple patterns and the specification of the files to
be processed via the standard input or the argument files.
See also: rep(1) rep(-x) rpl grep(1) regexp(x-qmisc)
^^ rls recursive list of files
rls is a recursive ls(1) but with extended facilities for
output field selection, selections of the depth of descent,
selection of files and directories to be listed, etc.
rls has a -F flag that allows the specification of fields to
be output. See lls(-x) or lls for a description of the fields.
rls is used in FSIC package qef script to create lists of all files
and/or directories in the selected tree.
See also: rls(1) rls(-x) lls FSIC
^^ rmlist remove files named in input
rmlist reads its argument files or its standard input and removes the
files (and optionally the directories) named by those inputs.
rmlist is used to remove files and/or directories named by files.
qef invokes rmlist to implement the Remove* directives.
rmlist is also used in FSIC package qef script to remove empty
files when lists have been generated.
See also: rmlist(1) rmlist(-x)
^^ rootvrs create or modify the root.vrs file
rootvrs is used to create an initial root.vrs file at the top of a
source or object tree. If a root.vrs file already exists, rootvrs may
be used to modify a root.vrs file. Furthermore rootvrs can update
the current directory's root.vrs file to reflect changes in the
root.vrs file of the ``parent'' directory (i.e., the next root in
the RootPath).
Normal root.vrs files contain typically contain the following:
BuildHost -- name of the host used for qremote builds
BuildSys -- type of the host system (to check build validity)
ConfigName -- name of the configuration
ConfVrs -- name of the configuration file
_DestDir_ -- the Destination directory
EditBranches -- version control option forcing branches
OldRoot -- old source root
Project -- name of the product
QefAdm -- name of the qef administration directory
QremoteEnv -- envset to be used by qremote
Revision -- default revision number
RootAlias -- alias or alternative name for the root directory
RootPath -- list of root directories
SysVrs -- basename of qvrs file to be used host vars file
TreedirsList -- name of treedirs input file list
TreeType -- type of the tree (e.g., baseline, working, object)
TreeType[] -- types of the other roots
VCBranch -- displacement from VCRoot of files for tree
VCRoot -- root of the version tree (if not LastRoot)
VCSys -- the version system
See also: rootvrs(1) rootvrs(-x) root.vrs(x-qvrs) treedirs
^^ rotf select fields of input lines for output
According to Stephen Lane:
"Every good Q-Tree command uses rotf at least twice".
rotf, which is pronounced `wrote-eff', reads lines from its input
files (defaults to the standard input) or the files named within the
argument files (if the -f flag is specified) breaks those lines into
fields as delimited by the specified character (defaults to tab) and
outputs the fields in the order and format specified by the selector.
Purists might think that it duplicates some of awk(1)'s functionality,
and it does, but in a much easier and more reliable way. Furthermore,
rotf predates awk and as such the author never learned to use the
latter well.
See also: rotf(1) rotf(-x) transl cut(1)
^^ rpl replace, print, or delete named lines
rpl reads lines of the form:
<file>:<address><action><text>
The named file is opened and the actions are performed. If the -r
(for replace) flag is specified, the modified file is written back
into the original file. Otherwise the modified file is written to
the standard output.
The actions include line insertion, deletion, replacement, and output.
A common scenario is to use rep (or grep(1)) to extract lines from
a set of files, modify the retrieved lines and use rpl to replace the
original lines.
Many programs, such as rep(1), have a -r flag that generates
rpl input.
getlist(1), which may not be available, was created to get for
edit the files named in rpl input.
See also: rpl(1) rpl(-x) rep
^^ rtabs align fields by inserting padding
rtabs reads lines from the argument files (defaults to the standard
input) and outputs the fields of the input lines padded and aligned
(by inserting blanks or dots) as specified by an argument.
The fields are delimited by a specified character (default tab) or
white space. The output format specification supports right or left
justification. rotf and transl are very useful when preparing input
for rtabs as they can provide the facilities to skip or reorder fields
or to insert arbitrary characters, which rtabs does not.
See also: rtabs(1) rtabs(-x) rotf transl
^^ sdba output statistics about sdbm database
sdba outputs information about the blocks of the specified argument
dbm database.
The first line is the block size as in:
Block Size=4k
For each non-empty block in the .pag file a line of the following form
is output:
#0: 53 entries; 91% used; 82 free
For each empty block, sdba outputs:
#16: no entries.
See also: sdba(1) sdba(-x) ldbm kdbm
^^ setbytes set specified offsets to strings
setbytes copies its argument input file (defaults to the standard
input) to a temporary file /tmp/set??????. Then, for each argument
offset value pair, setbytes seeks to the specified offset of the
temporary file and writes the value string. Options to take or drop
parts of the input file are also supported.
setbytes can be very useful, but is provided to facilitate setting
the name of the database in the sysnm binary. See sysnm(1) for a
description of how setbytes is used.
See also: setbytes(1) setbytes(-x) fndstr sysnm
^^ sfdchk check strfix dictionaries for valid patterns
sfdchk (StrFix Dictionary CHecK) reads strfix dictionaries and checks
the values assigned to variables for validity as specified by an
input specification. This specification consists of the records
containing three fields -- the variable, a regular expression (see
regexp), and an understandable explanation of the legal values.
For example, the following specification:
KEEPFIDS ^-/^[0-9]+$/ an unsigned number
specifies that the value assigned to KEEPFIDS must be empty (the
special interpretation of the `^-' or a string of digits.
sfdchk compares each variable setting in the input dictionaries to
ensure that their assigned values match the associated regular
expression. Any discrepancies are reported.
See also: sfdchk(1) sfdchk(-x) strfix regexp(x-qmisc)
^^ sfsic source file system integrity check and db maintenance
sfsic is used to compare the lists of existing source and version
system files against the FSIC files.fl list.
Typically sfsic is used in the fsic(x-qsg) script to create the ,s.errors,
,s.tmps, and ,s.pfiles files which should be used to correct any
discrepancies.
See also: sfsic(1) sfsic(-x) FSIC(x-qfsic) files.fl lib/sfsic.cf
^^ shfix process input file incorporating output of embedded commands
shfix copies its argument files (defaults to the standard input) to
the standard output, processing any lines that begin with a `
' to
perform special functions. The most important special function is to
incorporate the output of a shell command. Other functions provide
facilities to build those shell commands and to incorporate the names
or versions of files and the values of argument registers into the
output or the shell commands.
The shfix -X flag describes the input file syntax.
See also: shfix(1) shfix(-x) shfix(x-qsg)
^^ sls source path ls
sls outputs a list of all the files in the source path (as
specified by SrcPath in qvrs files), eliminating those files
for which a file with the same basename exists in an earlier
directory, or for which another file can be assumed to be the
source (e.g., x.y is source for x.c). The -s flag also reduces
the output to those files have suffixes named by the @Suffixes
variable or in the default string. sls is the default srclist._
generator. The following is the command used by default for
qsg scripts (unless overridden by setting SLScmd).
sls -Ls
The -L flag specifies the output is saved in srclist._ and changes
to the file are reported.
See also: sls(1) sls(-x) SrcPath(x-qvrs) Suffixes(x-qvrs)
SLScmd(x-qvrs) _F_sls(x-qvrs)
^^ srclist check the srclist._ file
srclist reads a list of file names from the standard input or as named
in the argument files and compares that list against the file list
contained in the file srclist._. If files named in srclist._ are not
named in the input list, or vice versa, these discrepancies are
reported and a new copy of srclist._ is created.
srclist is actually a special case of filelist that is equivalent to:
filelist -fmnuv srclist._
srclist was created and used to maintain the srclist._ database used
by qef and its script generator qsg. The default source database
command used to be:
sls -s | srclist
A full description of the above command is given in qef(1). However,
due to efficiency considerations, srclist's functionality has now been
added to sls directly.
See also: srclist(1) srclist(-x) filelist sls
^^ strfix replace variables according to replacement dictionary
strfix is used to transform a prototype file into a configured file
by substituting embedded variables with values assigned to those
variables in a dictionary file given as an argument to strfix.
It is used frequently within qef systems to create configuration
specific header and data files.
See also: strfix(1) strfix(-x) finclude
^^ subdist create sub-distribution from master file lists
The command:
subdist -f subspec flist
reads subspec (defaults to the standard input) as a specification of
files and directories to be extracted from the input flist (defaults
to the standard input) and outputs the selected files to the standard
output. The flist file should contain white space separated pathnames.
For obvious reasons subspec and flist may not both be defaulted to
the standard input.
The syntax and semantics of subspec is explained in subdist(-x).
subdist is most often used to extract sub-distributions from a
full distribution list.
See also: subdist(1) subdist(-x)
^^ suprep suppress repeated fields
suprep copies its input files to the standard output suppressing
repetitions of selected fields and performing some additional output
massaging when the selected fields change.
Note: rotf is useful preparing input for suprep. ffill is almost
suprep's inverse.
See also: suprep(1) suprep(-x) rotf ffill
^^ sysnm output symbolic system name or check if it matches arguments
sysnm outputs or tests the symbolic name of the current operating
system (System[Name]) according to a line in sysnames.tab selected
by a search done using uname(1) strings.
sysnm is equivalent to the command:
system -n
sysnm is a link to system, which if invoked using a name that matches
*sysnm, the -n flag is assumed.
Note: To facilitate the determination of the type of a system at
login, prior to setting $PATH which may itself depend on sysnm,
sysnm should be copied to a directory in the initial
$PATH such as /bin or /usr/bin.
See also: sysnm(1) sysnm(-x) sysnames.tab system System(x-qvrs)
^^ system output system name or check if it matches arguments
system outputs or tests the name of the current operating or host
system according to names specified by a line in <Q>/data/sysnames.tab
which is selected by pattern matching the catenation of the uname(1)
system, release, and machine fields.
The default output is the same as value of the qvrs variable @System,
the eight field of the sysnames.tab line.
system is sometimes used in shell scripts, as described in system(1),
to select actions based on the system.
sysnm is a link or copy of system that assumes the -n flag which
outputs the short symbolic system name. If system is invoked using a
name that matches '*sysnm', the -n flag is assumed.
See also: system(1) system(-x) sysnames.tab sysnm System(x-qvrs)
^^ tchown change ownership and mode according to a template
tchown changes the ownership and protection of files according to a
template given in its file arguments, or the standard input if file
arguments are not given. tchown is intended for use after
transferring a set of files to a new system or to ensure that files
and/or directories exist and have the correct ownerships and modes at
the end of an installation. The instal program records its chown(2),
chgrp(2), and chmod(2) errors in tchown input format -- see instal(1).
When instal installs a file with special modes or settings that cannot
be set due to permissions and the -I flag was specified, the failure
is recorded in the file named by InstLog (with the `.log' replaced by
`.fix'). The actual problem is recorded using tchown input format thus
facilitating quick rectification by applying tchown to the .fix file.
Note: If rls(1) or lls(1) are available the format `bUGf'
produces output lines in the tchown input form.
See also: tchown(1) tchown(-x) instal _F_instal(x-qvrs)
InstLog(x-qvrs) lls instal chstat wmode
^^ touchfiles list or create touch files
touchfiles is used to list existing _Touch_ files, list the
directories of @TouchPath, or to create or touch new files.
Basic commands are:
touchfiles # list all touchfiles
touchfiles xx # list all touchfiles for xx
touchfiles -f # list all touchfiles without times
touchfiles -p # list @TouchPath directories
touchfiles -c xx # create or touch touchfile xx
See also: touchfiles(1) touchfiles(-x) _Touch_ TouchPath(x-qvrs)
^^ traits output traits table
traits outputs the traits database <Q>/data/traits/<host>.tab.
The traits database is a set of variable/value pairs used to store
system, host, and site settings such as capabilities, pathnames, and
special values such as QDSRV_HOST.
The data/traits/<host>.tab file is created by mktraits from the traits
source files traits.vrs and traits.ext.
Note: Whenever mktraits -Ru is run, any traits/<host>.tab file
that is older than either of the source files is removed.
Running traits or any query of the traits database via the
libdtree.a A.P.I. will recreate the file if necessary.
See also: traits(1) traits(-x) mktraits trait(x-qvrs)
^^ transl translate input fields
transl reads its input lines and reformats (i.e., translates) them
according to an argument format and outputs the result. The format
allows the selection of fields and arbitrary strings and characters.
The -p pat flag restricts processing to those lines that match
the regular expression pat.
See also: transl(1) transl(-x) rotf
^^ treedirs mkdir selected or all sub-directories of a qef tree
treedirs is used to create a shadow object or working tree. Normally, it
creates the directories for the files named in @TreedirsList (defaults to
treedirs.lst in @TreedirsPath). If such a file is not found, treedirs
searches the @RootPath trees for the construction files.
The -X flag to treedirs gives a complete description of the files it
processes and creates.
treedirs is usually the second step when one is modifying or building
a system, the first being to use rootvrs.
treedirs -L outputs the list of construction files for the argument
directory tree. The construction files are:
qeffile
qeffile2
root.vrs
tree.vrs
suppress.vrs
nobuilds.vrs
noqfile.vrs
The generated list can be saved in treedirs.lst (the default file
read by treedirs). Alternatively treedirs can walk the directory
tree itself looking for the files of relevance.
See also: treedirs(1) treedirs(-x) treedirs.lst rootvrs mkqtree
TreedirsList(x-qvrs) TreedirsPath(x-qvrs) ExcludeDirs(x-qvrs)
suppress.vrs nobuilds.vrs noqfile.vrs
^^ untouch set file times
untouch sets the last access and modification times of the argument
files to a specified time, similar to the standard tool touch(1).
untouch provides additional facilities such as setting the times
to that of another file or a specific date.
See also: untouch(1) untouch(-x) touch(1)
^^ upd update conventionally named versions of files
upd is used to rename files to create a pseudo version system. Given
a file called eg, the command:
upd eg
where files eg-2, eg, eg+1, and eg+3 exist, upd will
perform the following moves:
mv eg+3 eg+4
mv eg+1 eg+2
mv eg eg+1
mv eg-2 eg-1
If given a filename containing a `.', upd uses `o's (for old) and `n's
(for new) to create old and new versions of a file as in:
file.nnc
file.c
file.oc
file.oooc
go creates an output files called ,.g but performs a upd-like
renaming such as:
mv ,.oog ,.ooog
mv ,.og ,.oog
mv ,.g ,.og
See also: upd(1) upd(-x) go
^^ vcc create, compile, link, and remove version string source file
vcc is an interface to cc that prepares a version file and then
invokes the argument cmd, replacing +VFILE+ by the created version
file. A typical use is:
vcc -m mimk cc mimk.o +VFILE+ -ldtree
vcc creates file _vmimk.c, which contains:
char version[]={"V@(#)Mimk 6.3 - 95/06/23 03:59:36 - linux"};
with the appropriate values for the version number and date (see
mkvernum(1)). The command `cc ...' is then run, with the `+VFILE+'
argument replaced by _vmimk.c. Upon completion, the version file is
removed (unless the -k flag is specified).
See also: vcc(1) vcc(-x) mkvernum MkvernumFormat _F_mkvernum_cc(x-qvrs)
ReportMkvernum Revision RevisionString
^^ vci version control system interface
vci is a qsg clone that provides basic version control facilities
such as checking in or out a file, reporting what files are locked,
outputting the differences between a current file and its version
system release, and so on.
These facilities are provided by two qsg libraries: vci and
@VCSys (@VCSys is usually set in the root.vrs vile). The vci
library provides general utilities, whereas the @VCSys library
provides the implementations of the various facilities for the
specific version system. The facilities provided should be:
changed list changed files (see cmdcmp)
ci check in argument files
co check out argument files
diff produce differences between file and its v-file version
lock lock the argument files
new create a new version administration file (v-file)
novfiles list files for which there is no v-file
rlog produce history logs for argument files
tell tell which files are checked out for edit
unget unget or uncheck out argument file, discarding changes
vdiff run qgdiff on argument files and their v-files
See also: vci(1) vci(-x) qsg VCSys(x-qvrs)
^^ vernumcomp compress the mkvernum database
The version database created maintained by qdsrv for mkvernum is
usually <Q>/data/mkvernum.db. Every time mkvernum, or its alias
vcc, is invoked a line of the following form:
module version(count) system host directory user time
is appended to the database, which will therefore be growing
monotonically. If left unattended this database can get very big and
loading it can be time consuming. However, other than the last record
for each module, which contains the last count for that module, most
records are not required, other than for historic and auditing purposes.
vernumcomp reads input, copying comments and the last record for
each module in the database to its output. It also appends its input
to a savefile if specified.
The following is a recommended procedure for compressing the database,
while saving old records for possible future consultation.
cd `pathto qt/data` # chdir to the qtree data directory
gunzip mkvernum.odb # uncompress old record file
qdmgt freeze # freeze the qdsrv until new file created
vernumcomp -i- -o- -s mkvernum.odb # compress the database
qdmgt reload # unfreeze the qdsrv
gzip mkvernum.odb # compress the database
See also: vernumcomp(1) vernumcomp(-x) mkvernum.db mkvernum qdsrv vcc
^^ wcci windows c compiler interface
wcci is a program that provides a rational (i.e. Unix cc-like)
interface to native compilers on Microsoft Windows systems.
By default, it is configured to drive Microsoft's compiler and linker
(CL.EXE and LINK.EXE) but it can also be configured to drive other
compilers through the Wcci* qvrs variables. See wcci(1) for details
on how wcci works and how it can be configured.
See also: wcci(1) wcci(-x)
^^ whats whats 2 + 2
whats evaluates its argument list or its input lines as
arithmetic-expressions and outputs the results, possibly in a
specified base.
The expression may contain all the C binary, unary, and ?: operators
that may be used on ints.
See also: whats(1) whats(-x) arithmetic-expression(x-qmisc)
^^ wmode set the write modes for files
wmode sets or resets the write mode bits of the argument files or
the files named by the argument files or the standard input.
It provides flags to set or clear write bits with simple flags.
Furthermore it outputs the current write-bits as a flag so that
the bits can be restored trivially.
Note: wmode used to be called wp but was renamed.
See also: wmode(1) wmode(-x) chstat tchown chmod(1)
^^ wot output embedded sccs id strings
wot searches the argument files or the files named by files or
the standard input if the -f flag specified or the standard input
(if no arguments or -f) for occurrences of the pattern that the
SCCS program get substitutes for %Z% (i.e., @(#)) and prints
out what follows up to the first `"', `>', newline, back-slash,
or null character. It also supports a -p flag which specifies that
wot is to search $PATH for the files to be processed, and a -v flag
that limits the output to strings beginning with `V@(#)'.
Note: mkvernum and vcc embed such strings into their products,
thus wot may be used to determine the version of the tools
being run.
For example, the command:
wot -vp qef qefgui
will output the version strings for the $PATH's qef and qefgui.
See also: wot(1) wot(-x) what(1) mkvernum
^^ x-html html qsg library eXplanatory D.B.
This x_db database contains items describing the scripts of the
qsg library <Q>/lib/qsg/html.qsl. This library contains
scripts to aid in creating HTML files.
See also: x_db x_db(-x)
^^ x-ldtree x_db database describing routines of the -ldtree library
Companies that use the full Q-Tree set of tools often use the man3db
system to document subroutines and facilities of libraries. Tips
database entries describing the library's components are embedded in
the C source files as comments. The man3db program is then used to
extract those comments and convert them from the TIPs format into a
variety of products such as man3 sections in troff or frame, lint
libraries, software inventories and x_db databases.
x-ldtree and any other Q-Tree program whose name is of the form x-lname
are x_db databases that describe the library -lname.
Such databases can be examined using the qef gui by selecting those
databases using the Databases button in the View pull down menu of
the Qef Info Tools window.
x-ldtree may not be available on the current system.
See also: x_db man3db(1) x_db(-x)
^^ x-qef QEF facilities and tools eXplanatory D.B.
This x_db database, of which this is an item, contains items describing
the tools, features, macros, controls, and files of the qef system.
See also: x-qef(1) x_db x_db(-x)
^^ x-qefdirs qefdirs eXplanatory D.B.
This x_db database describes the syntax and semantics of the
other qef script generator qefdirs. Whereas qsg is for individual
directories, qefdirs is for trees providing the glue to control
builds over trees and sub-trees of directories.
See also: x-qefdirs(x-qefdirs) qefdirs
^^ x-qefeg prototype qef files eXplanatory D.B.
This x_db database contains a number of prototype qeffile files
and example qvrs files.
See also: x-qefeg(1) x-qefeg(x-qefeg) x_db(-x)
^^ x-qefgui qef graphical user interface eXplanatory D.B.
x-qefgui is an x_db database contains items describing different
aspects of the qef gui. These items are displayed by the various
help buttons within the gui.
See also: x-qefgui(x-qefgui) x-qefgui(1) x_db qefgui qefgui(1)
x_db(-x)
^^ x-qefpp qef preprocessor controls and macros eXplanatory D.B.
This x_db(1) database describes qef preprocessor qefpp, its
controls and macros.
See also: x-qefpp(x-qefpp) x-qefpp(1) x_db(-x) qefpp
^^ x-qfsic file system integrity (fsic) package eXplanatory D.B.
This x_db(1) database describes FSIC (the File System Integrity
Check) package, its tools, files, procedures, error messages, and
corrective measures.
See also: x-qfsic(x-qfsic) x-qfsic(1) x_db(-x) FSIC
fsic-intro(x-qfsic)
^^ x-qmisc Q-Tree miscellany eXplanatory D.B.
x-qmisc is an x_db database contains items describing different
procedures and facilities of the Q-Tree system.
Note: Some of the other x_db databases will refer to items in this
database.
See also: x-qmisc(x-qmisc) x_db x_db(-x)
^^ x-qproc software process procedures eXplanatory D.B.
x-qproc is an x_db database containing items describing a typical
software procedures for a software product to be built using qef.x
See Chapter 12.10 of the Guide regarding the creation of a company
specific procedures manual.
See also: x-qproc(x-qproc) x_db x_db(-x)
^^ x-qsg qsg and its support library eXplanatory D.B.
This x_db(1) database describes qsg (the Qef Script Generator), its
tools, input syntax, and the scripts of the standard qsg library.
See also: x-qsg(x-qsg) x-qsg(1) qsg x_db(-x)
^^ x-qvrs qvrs variables, facilities, and files eXplanatory D.B.
This x_db database describes the files, syntax and features and many
of the variables of qvrs(1).
See also: qvrs x-qvrs(1) x-qvrs(x-qvrs) x_db(-x)
^^ x_db x_db database front end
x_db serves as the front end to an x_db (x for eXplanatory) database.
For example this is the x-qef x_db database. An important feature
of x_db is that when invoked using the command x-Name, Name is taken
to be the name of the database to be used. x_db when invoked as
x-Name, will search for DIR/Xdb.dir/Name.xo, where DIR is a directory
named by $PATH.
x_db databases are used to document many of the Q-Tree tools such as
x-ldtree x_db database describing routines of the -ldtree library
x-qef QEF facilities and tools eXplanatory D.B.
x-qefdirs qefdirs eXplanatory D.B.
x-qefeg prototype qef files eXplanatory D.B.
x-qefgui qef graphical user interface eXplanatory D.B.
x-qefpp qef preprocessor controls and macros eXplanatory D.B.
x-qfsic file system integrity (fsic) package eXplanatory D.B.
x-qmisc Q-Tree miscellany eXplanatory D.B.
x-qproc software process procedures eXplanatory D.B.
x-qsg qsg and its support library eXplanatory D.B.
x-qvrs qvrs variables, facilities, and files eXplanatory D.B.
Warning: x-ldtree may not be available.
See also: x_db(1) x_db(-x) xdbs xdbmk
^^ xdbmk create an x_db data base
xdbmk converts a source form x_db database to the binary form.
Note: x_db and all its aliases such as x-qef, x-qvrs, and x-qsg
support a -S flag which will output the source form of the
selected items, hence:
x-qef -AS
will dump the entire source of this database and xdbmk can be
used to recompile it.
Note: xdbmk's -X flag outputs the syntax of the input language.
To facilitate use, the input syntax is summarized here.
Input format:
%{ [key ...] start of a major item -- keys beginning with `*'
taken to be group names and duplicates not reported
%{- [key ...] start of a minor item
%} end of an item
%A key ... add addition aliases or keys for the item
%D description set the short description for the database
%i file include named file
%%... line beginning with literal %
%# comment comment line - ignored
%c [key ...] produce columns of selected keys (default major items)
%l [key ...] produce list of selected keys (default major items)
%S ... line is maintained in database but never output
used to embed SID lines in source and binary
%; %; embedded in a text body is not output to facilitate
use of unexpanded SCCS keywords (e.g., %A)
for literal `%;' use `%%;;'
%<tag str %; If outputting for tcl, output str followed by tag;
common tags are: manref, B (bold), I (italics), btn (button)
... %?word treat word (or up to %;) as manref as in word
... %!word treat word (or up to %;) as italics as in word
... %$word treat word (or up to %;) as bold as in word
... %*word treat word (or up to %;) as btn as in word
... %% ... a literal % character
See also: xdbmk(1) xdbmk(-x) x_db
^^ xdbs list all or specified x_db databases or all their topics
xdbs is used primarily by the qef gui to retrieve the names,
pathnames, and descriptions of all or specified x_db databases.
It will also produce all the available topics for all or specified
databases. A flag is provided to cause the output to be formatted
as TCL lists to facilitate processing within the gui.
See also: xdbs(1) xdbs(-x) x_db
^^ xfinterp process -x flag outputs
xfinterp reads its standard input which is assumed to be the output
of Q-Tree programs run with the -x flag. This input is processed
to format the input to produce one of the following forms:
* description lines with troff formatting (-d)
* description lines (-s)
* skeleton troff manual page (-m)
* skeleton eml-form manaul page (-f)
* troff formatted form of -x outputs (default)
* description lines (-d)
One useful application of xfinterp is to produce a list of all the
programs in Q-Tree bin using:
cd `pathto qtbin`
l -se | lash -lf "./%1 -x" | xfinterp -s
See also: xfinterp(1) xfinterp(-x)
x070.qh - 8.12 - 00/05/13 |
|