Go to the first, previous, next, last section, table of contents.


6 Subcommands

In subcommand descriptions, arguments appearing in square brackets ([]) are optional. An argument followed by `...' indicates "one or more".

Options have both a short form (hyphen followed by one letter) and a long form (introduced by two hyphens). Certain options, defined in the first subsection below, are standard: valid on all commands. Other options are listed with the individual subcommands to which they apply, with their long forms in parentheses.

6.1 Specifying Projects

A project operand identifies the name of the project to be acted on (a simple label, denoted P below), the name of the project-version descriptor file (`P.prj'), and a root working directory (denoted D below). In the usual case, project is just the name of a project (a simple label), in which case P is project and D is the current directory (`.'). The full story is as follows:

Some subcommands allow you to omit the project operand. In those cases, it defaults to the current directory (`.'), so that by the preceding rules, there must be a single `.prj' file in the current directory, which then implicitly supplies the project name.

When the directory D determined by these rules is not the current working directory `.', the effect is as follows:

6.2 Specifying Files and Directories

The file-or-dir operands restrict a subcommand to operate only on specific files within a project version. Each must be the name of a file or directory in the relevant project version. A directory operand stands for all files under that directory (i.e., in it or, recursively, under its subdirectories). The default file-or-dir operand is the working directory specified by the project operand (see section 6.1 Specifying Projects). Usually, this is simply the current directory (`.'), specifying everything under the project directory.

6.3 Options

This section collects definitions of options used in PRCS subcommands. Many options have both a short form (e.g., -f) and a GNU-format long form (e.g., --force); in these cases, the long form is listed immediately below the short form. In the descriptions below, a Standard option is one that is legal on all subcommands, and an Option is valid on one or more subcommands.

Option: --all
Used in prcs execute to indicate that the specified command is to be executed just once, with all files as arguments.

Option: -d
Long Form: --delete
Tells PRCS to perform some optional deletion action. Used by prcs populate to indicate that files that are not present in a working directory are to be removed from the Files list.

Standard Option: -f
Long Form: --force
Force: resolve what would normally be interactive queries in some fixed way, depending on the subcommand, assuring that PRCS will never use the standard input.

Standard Option: -h
Standard Option: -H
Long Form: --help
Prints out help very similar to the contents of this section.

Option: -i
Long Form: --immediate
Causes certain actions to occur immediately during execution of a command. For prcs uncompress, causes the files in a project to be uncompressed on the spot, rather than incrementally as they are needed.

Standard Option: -j number
Long Form: --jobs=number
Allows PRCS to spawn up to number child processes at once. Almost always, 2 or 3 will result in faster operations and higher machine load. Experimentation will yield the best results.

Option: -k
Long Form: --keywords
Causes prcs diff to compare keywords, instead of stripping them before comparison.

Standard Option: -l
Long Form: --long-format
Standard Option: -L
Long Form: --long-long-format
Various long formats, depending on the subcommand.

Option: --match pattern
Used in prcs execute to indicate that the names of the files to be processed, or the options attached to them, must match pattern.

Standard Option: -n
Long Form: --no-action
Indicates that the command is to report what would happen in the absence of `-n', without changing working files or the repository.

Option: -N
Long Form: --new
In prcs diff, produces comparisons against empty ("new") files where a file is missing in one of the versions being compared. If you intend to use the -N option and later apply the diffs you should make sure to always use one of the context diff formats. See the PRCS_DIFF_OPTIONS environment variable See section 12 Environment Variables.

Option: --not pattern
Used in prcs execute to indicate that the names of files to be processed, or the options attached to them, must not match pattern.

Standard Option: -q
Long Form: --quiet
Suppress normal informational messages.

Option: -p
Long Form: --preserve
Preserve permissions on files that are checked out, ignoring any standard protections the user may have set for newly-created files (as by the file mode creation mask in UNIX).

Option: -P
Long Form: --exclude-project-file
Prevent situations where the project file may be treated as an ordinary file. For example, this causes prcs diff not to output changes in the project files of each version.

Standard Option: --plain-format
Turns off PRCS's default formatting of its output, which is to break lines at the screen width and surround filenames with single quotes. Setting the PRCS_PLAIN_FORMAT environment variable has the same effect (see section 12 Environment Variables).

Option: --pre
Used in prcs execute to indicate that directories are to be listed in pre-order: directory names first, then their non-directory contents, then subdirectories.

Option: -r version
Long Form: --revision=version
Identifies a version of a project. The version is a version specifier. See section 5 Version Names and Specifiers. The space between `-r' and version is optional.

Standard Option: -R directory
Long Form: --repository=directory
Use directory as the repository, ignoring the value of the PRCS_REPOSITORY environment variable.

Standard Option: -s
Long Form: --skilled-merge
Turn off most of the safety features of prcs merge, allowing a skilled user finer control over the process. See section 6.9 Prcs merge.

Option: --sort=type
Set the type of sorting for the info command to perform on its output. The two valid values for type are `version' and `date'. The default is version.

Option: -u
Long Form: --unlink
When PRCS writes a working file, it generally does so by replacing any existing file of that name. With this option, however, if the file to be written is a symbolic link, that link is removed and a new file is created. Thus, the file that was originally linked to is unchanged.

Standard Option: -v
Long Form: --version
Prints the version of PRCS and exits.

Option: -z
Long Form: --compress
Indicates that a command should perform (de)compression.

6.4 Prcs checkout

Command: prcs checkout [option ...] [project [file-or-dir ...]]

ADDITIONAL OPTIONS: `-r', `-p', `-u', `-P'

Create a working copy of a version of the specified files and directories in project rooted in the current directory (creating any subdirectories that don't exist). You may use the option `-r' to select a version. The default major and minor version specifiers are both @.

You will be warned when a check-out would change the contents of an existing working file, and interactively given the choice of replacing the file with the version being checked out, or leaving the existing file alone. Existing working files that do not differ from corresponding project files are not modified (their changed and modified dates do not change). The `-f' option will cause checkout to overwrite all files that differ without asking.

When PRCS overwrites a working file that is a symbolic link, then (unless the :symlink option is specified for that file), it will overwrite the file that the link references, without changing the link itself. With the `-u' option, PRCS will instead remove the link and create a new file.

If a working project-version descriptor for project exists, then the project-version descriptor is treated as an ordinary file for purposes of check-out. A check-out with a non-defaulted file-or-dir list that does not contain the descriptor therefore leaves the descriptor unchanged. Further, if the `-P' option is supplied, the project descriptor will not be created at all.

Files that are checked out are restored to the protections recorded for them at check-in time, usually modified (on UNIX systems) by the user's file mode creation mask (see the UNIX manual entry for umask(1)). With the `-p' option, this mask is ignored, and the command restores the files' protections to exactly their state at check-in.

Returns a status code of 0 if all goes well, and non-zero if there are errors.

6.5 Prcs populate

Command: prcs populate [option ...] [project [file-or-dir ...]]

ADDITIONAL OPTIONS: `-d'

Add each file in the file-or-dir list to the Files list of the `.prj' file identified by project, without modifying the repository. For each directory in file-or-dir, recursively adds all files in that directory structure (or the directory itself, if it is empty). The file-or-dir operand list defaults to the current directory.

Without the `-d' option, any files already in the Files list remain there unchanged. With `-d', populate will prompt you about removing files from the Files list that are listed there as appearing under one of the directories given in the file-or-dir list, but are not found in the working directory. With `-d' and `-f', it will remove them silently.

For example, suppose the file `P.prj' lists files `C', `D1/A', `D1/B', `D2/A', `D2/B'. Suppose a working directory contains files `A', `D1/B', and `D2/B'. Then the command

prcs populate -d P

would remove files `C', `D1/A', and `D2/A' from the Files list of `P.prj', and add file `A'. For the same initial `P.prj' file, the command

prcs populate -d P D1

would remove `D1/A' from `P.prj', and would add nothing.

New files are added with null internal file identifiers. Populate attempts to fill in the :symlink and :directory options. It also applies a heuristic test to each file added to guess whether it is a non-text file; for each file it judges to be a non-text file, it includes the :no-keywords option for that file (see section Files attribute).

6.6 Prcs depopulate

Command: prcs depopulate [option ...] [project [file-or-dir ...]]

ADDITIONAL OPTIONS:

Remove each file in the file-or-dir list from the Files list of the `.prj' file identified by project, without modifying the repository. For each directory in file-or-dir, recursively removes all files in that directory structure (or the directory itself, if it is empty). The file-or-dir operand list defaults to the current directory, but since removing all files is probably not something the user wants to do, it queries first if no file-or-dir is supplied.

6.7 Prcs checkin

Command: prcs checkin [option ...] [project [file-or-dir ...]]

ADDITIONAL OPTIONS: `-r', `-s'

Create a new version of the specified project in the repository. Copy all files listed in the Files attribute of the descriptor (`project.prj'), taking those specified in file-or-dir operands and the descriptor itself from the working files. Also, modify the descriptor to reflect the contents of the new version. See section 8 Descriptors.

If file-or-dir arguments are provided, they must name files and directories listed in the Files attribute. Only those working files are checked in; other files listed in the project descriptor are carried over from the file versions listed for them in the Files attribute. It is an error for these other files to have null internal file identifiers in the `.prj' file.

A check-in records the access protection on each file (reading it from the working file). It records symbolic links with the :symlink option and empty directories with a :directory option. You could have, for example, a Files attribute as follows:

(Files
  (empty () :directory)        ; an empty directory
  (pointer () :symlink)        ; a symbolic link
  (realfile () :no-keywords)   ; the only real file in the list
)

PRCS reads the contents of a symbolic link from the link at check-in time. It is thus wise to use relative pathnames inside the project. Directories with a :directory option need not be actually empty, but this ensures their creation at checkout. It is an error to have a :no-keywords option in the same file as a :symlink, or :directory option.

The new version will have the latest minor version number for the specified major version. The `-r' option may specify a major version; any minor version specified is ignored. The `-r' option defaults to `-r.@', thus taking the major version from the `.prj' file.

Let LV denote the last minor version on the branch being checked into. A checkin is considered safe if the nearest common ancestor of LV and the working version is LV (see section Parent-Version attribute). This is to insure that the version being checked in is a descendant of the version at the head of the branch before checkin. Otherwise, changes at the head of the branch are clobbered. Unless the `-f' option is present, PRCS will warn you if a checkin is not safe and allow you to abort.

With `-l' present, PRCS will list which files are modified, inserted, deleted, or renamed, relative to the real working version prior to checkin. With `-L', PRCS will list all these changes in addition to listing which files are unmodified.

Returns a status code of 0 if all goes well, and non-zero if there are errors.

6.8 Prcs diff

Command: prcs diff [option ...] [project [file-or-dir ...]] [-- [diff-option ...]]

ADDITIONAL OPTIONS: `-r' (once or twice), `-k', `-N', `-P'

Compare the (partial) contents of two repository versions of a project or of a repository version and a working version. When file-or-dir arguments are present, they restrict comparison to the specified files or subdirectory trees. The project argument may be defaulted if there is a single file with extension `.prj' in the current working directory, in which case PRCS takes its name (without `.prj') as the project name.

The options may specify zero, one, or two versions (using `-r' options). Specifying no `-r' options is equivalent to supplying the single option `-r.', the version from which the current working directory was checked out. A `-r' option that specifies only a major version (leaving off the minor version and its preceding period) implicitly has a minor version of @. When one version specifier is given, the files in the indicated version are compared to the working files. The command's output notes any discrepancies in the contents of identically-named files, or in files present in one version but not the other. Two version specifiers cause the same comparison, but between two checked-in versions of the project.

Normally, diff canonicalizes keyword instances in the files it compares, removing the keyword values and leaving just the keyword name. As a result, two different versions of a file that differ only in their keyword values will compare as equal. The `-k' option causes diff to compare keyword values as well.

If a file is present only in one of the project versions being compared, diff will normally just announce that such a file occurs only in one of the versions. With the `-N' option, it will produce the same output it would if it instead treated the non-existent version as an empty file. This is useful when producing patch files that include new files as well as changed ones. Its effect is essentially the same as that of the same option in GNU diff when it compares directories.

Files in the two versions being compared are paired by their names and their internal-file families (see section Files attribute, for a description of internal-file families). That is, PRCS will assume that two files in the different versions correspond if they have the same name or the same internal-file family. This makes it possible to have conflicts (for example, when one switches the names of two files in a project descriptor); in those cases PRCS will ask the user to resolve the conflict.

The diff-options, if provided, are any options acceptable to GNU diff. @xref{(diff)Top}. The environment variable PRCS_DIFF_OPTIONS, if set, supplies a default set of whitespace separated diff-options.

If the file-or-dir is defaulted and `-P' is not supplied, or if file-or-dir contains the project descriptor, PRCS outputs differences between project descriptors.

Returns a status code of 0 if there were no differences, 1 if there were differences, and 2 if there were problems.

6.9 Prcs merge

Command: prcs merge [option ...] [project [file-or-dir ...]]

ADDITIONAL OPTIONS: `-r', `-u', `-s'

Find differences between working files and those of the selected version of project, and (unless `-n' is specified) try to modify the working files to reconcile them. The default major and minor versions are `-r.@'.

More precisely, the comparison takes place between three versions of project: the working version (called PW in what follows), the common version (PC) and the selected version (PS).

PW is the working version specified in the checked-out descriptor and consists of all files listed therein. PS is the version against which PRCS will reconcile changes, identified by the (possibly defaulted) `-r' option. A common version is chosen according to the following algorithm:

Each version, including the working version, has a list of parent versions. The parent versions establish an ancestry graph that is directed and contains no cycles. A version is an ancestor of another if it can be reached by following zero or more parents (see section Parent-Version attribute and section Merge-Parents attribute). PC is chosen from the set of all versions that are ancestors of PW and PS. If amongst this intersection, there exists a unique nearest common ancestor, then it is PC. If there is no such version, PRCS will complain and ask the user for help.

Files in the three versions are matched up both by name and by internal-file family (see section Files attribute). That is, PRCS will assume that two files in different versions correspond if they have the same name or the same internal-file family. This makes it possible to have conflicts (for example, when one switches the names of two files in a project descriptor); in those cases PRCS will ask the user to resolve the conflict.

A prcs merge will report discrepancies and (unless `-n' is specified) take actions as directed. The possible actions are as follows.

n
Do nothing.
a
Add the file from PS to PW.
r
Replace the working file with the file from PS.
d
Delete the file from PW.
m
Merge the file from PS with that from PW, inserting markers into the merged working file to show where the changes in PW (relative to PC) and those in the version from PS overlap. If the file from PC is missing, then an empty file is used for its contents. In general, you will have to edit the working file to resolve the discrepancies. If the versions in PS and PW are identical aside from keyword values, merging has no effect.
?
Print summary of options.
h
Print explanatory help message.
v
View differences between PS, PC, and PW (there is further prompting for which you want compared).

The `-f' option causes default actions to each discrepancy (see below). Otherwise, PRCS will ask the user to specify one of the possible actions. All of the actions except n modify the descriptor, either to remove the file from the Files list, or to modify its internal file identifier to the one from PS.

Like prcs diff, prcs merge canonicalizes files to strip keyword values before comparing them for discrepancies (see section 6.8 Prcs diff). In the descriptions that follow, saying that files are "equivalent" means that they are identical when canonicalized.

PRCS detects the following discrepancies:

When PRCS overwrites a working file that is a symbolic link, then (unless the :symlink option is specified for that file), it will overwrite the file that the link references, without changing the link itself. With the `-u' option, PRCS will instead remove the link and create a new file.

Whenever PRCS is going to replace a working file as a result of one of the actions above, it first moves the original file into the `obsolete' directory and gives it a unique name.

A partial merge takes place when not all files in the three versions are considered for merging. This can happen if a merge is aborted or the file-or-dir option limits the files under consideration. When this happens, PRCS records which files have been merged and their names in the working project's New-Merge-Parents attribute (see section Merge-Parents attribute).

A merge is considered complete when each file in each version has been considered once. A complete merge may be achieved by several partial merges. To prevent reconsidering the same file more then once, PRCS will not consider any set of files containing a file that was already considered in a previous merge against the same selected version unless the `-s' option is specified.

In general, the `-s' option allows the user to turn off all the safety features built into prcs merge. It will allow a user to merge files more than once, override the choice of an effective working version, restart a complete merge, and start a new merge without completing a previous merge.

By default, PRCS uses the GNU diff3 command to perform 2- or 3-way file merges when you choose the m action (@xref{(diff)top}). It is possible, however, to supply your own merge command. By setting the PRCS_MERGE_COMMAND environment variable to a program name, PRCS will call the named command instead of diff3 (see section 12 Environment Variables).

6.10 Prcs Rekey

Command: prcs rekey [option ...] [project [file-or-dir ...]]

ADDITIONAL OPTIONS: `-u'

Replace keywords in the selected files, according to the version named in the project file. Files whose contents would not change under keyword substitution are not modified. With the `-n' option, simply reports files that will change as a result of keyword replacement. See section 9 Keywords.

When PRCS overwrites a working file that is a symbolic link, then (unless the :symlink option is specified for that file), it will overwrite the file that the link references, without changing the link itself. With the `-u' option, PRCS will instead remove the link and create a new file.

You can use this command to update keywords in working files after performing a prcs checkin, which does not modify keyword values.

6.11 Prcs info

Command: prcs info [option ...] [project [file-or-dir ...]]

ADDITIONAL OPTIONS: `-r', `--sort'

Print information about versions of the named project. For each version listed, prints the project name, major and minor version identifiers, date and time checked in, and the user who checked in the version. With the `-l' option, also prints out the version logs and each project description. With `-L', also prints out the files constituting the version, their attributes, and their unkeyed MD5 checksum; the file-or-dir options in this case restrict the files or directories that are listed.

The `-r' option is special in this command in that it may contain any of the shell filename-generation pattern characters defined for the Bourne shell, sh: *, which matches any string of 0 or more characters; ?, which matches any single character; [...], which matches any of the enclosed characters; and [!...], which matches any character except one of the enclosed characters. These special pattern characters must be escaped to get them past the shell. The default for both the major and minor versions is *. The `-r' option is still interpreted as a separate major and minor version; that is, `-rFoo.*' matches `Foo.1', but not `Foo.Bar.1'.

The `--sort=TYPE' option sets the type of sorting that the info command should use. If TYPE is `date', versions are sorted by individual version date, otherwise the default, `version', is to sort by major version creation date.

6.12 Prcs admin

Command: prcs admin subfunction [option ...] [operand ...]

Perform various administrative subfunctions that generally have no effect on the abstract state of the repository. The available functions are as follows.

Subfunction: compress [project]

Encourages PRCS to save space in storing the data for project, even at the expense of slower processing. This command may take some time to execute. Interrupting it in the middle is safe, although it may lead to somewhat erratic space-saving behavior.

Subfunction: uncompress [option] [project]

ADDITIONAL OPTIONS: `-i'

Encourages PRCS to save time in processing commands against project, even at the expense of using more space--perhaps considerably more. With the `-i' option, PRCS will immediately expand the entire representation of project. Without the `-i' option, PRCS will increase its use of space only as needed. If disk space should run out, PRCS will leave the repository in a correct state.

Subfunction: access [project]

With the optional operand, interactively sets read and write permissions to all versions of project, in the repository, and (on systems that provide it) sets the group to which the files belong. This command allows the owner of a project in a repository to restrict the access that others have to its contents. One can specify that these files may only be read or may not be accessed at all.

Without a project operand, interactively sets read and write permissions to the repository itself, both for members of the repository directory's group, and for all other users. One must have at least read access to the repository to look at or check out any project (in addition to having appropriate access to the project itself). You must have write access to the repository to create new projects in it.

Subfunction: rebuild [option ...] [project]

Rebuilds internal repository data on project, possibly removing file storage for deleted project versions and verifying the integrity of all project versions. With the `-l' option, reports deletions. Unless there has been damage to the repository, this command generally has no visible effect on the notional contents of the repository.

Subfunction: init project

Create a new project in the repository containing no (non-empty) versions. Performing a prcs checkout on a non-existent project creates a blank working project descriptor without modifying the repository. The first prcs checkin for that project then creates a new entry in the repository. Normally, no other explicit initialization for the project's entry in the repository is necessary. However, with this method it is impossible to perform a prcs access before the first check-in, because there is no record of the new project in the repository. With prcs init, you can create a repository entry (containing no versions) that you can modify with prcs access.

Subfunction: pdelete project

Deletes a repository entry, permanently removing all versions and data from the repository.

Subfunction: pinfo

Lists all projects in the repository.

Subfunction: prename project

Renames a repository entry, similar to renaming during prcs unpackage.

6.13 Printing and Checking the Configuration

Command: prcs config

Print out all compiled-in values and their values, possibly altered by environment variables or command-line arguments. Also verifies that the executables named by $RCS_PATH, or its compiled-in default, are valid and checks their version numbers to see that they are not outdated.

6.14 Moving and Copying Projects

Sometimes, it is desirable to package up and move or copy an entire PRCS project, rather than a single version of a project (discussed elsewhere in section 11 Importing Project Versions.) One can move an entire repository using the usual UNIX tools for copying, moving, distributing, and packaging directories. For individual projects, it is preferable to use the package and unpackage subcommands in order to insure that all of PRCS's internal structure is maintained.

Command: prcs package project packagedfile

ADDITIONAL OPTIONS: `-r', `-z'

Creates a plain file named packagedfile, containing all the data in project. A value of `-' for packagedfile denotes the standard output. With `-z', the output file is compressed (in gzip format).

Command: prcs unpackage packagedfile [project]

Creates project in the repository to be a copy of the project from which packagedfile was created. The file packagedfile must have been created by prcs package (with or without the `-z' option). If project is omitted, it defaults to the name of the project from which packagedfile was created. If project exists in the repository, the user is prompted to delete the old copy from the repository. A value of `-' for packagedfile denotes the standard input. With `-n', it merely reports the name of the project that would be added.

If project differs from the original name as stored in packagedfile, the project is renamed. Renaming a project revises the history of the project; the result is as if the project had always been named project, with one exception: When checked out, project descriptor will have a comment inserted making note of the original project name.

6.15 Prcs execute

Command: prcs execute [option ...] [project [file-or-dir ...]] [-- command [arg ...]]

ADDITIONAL OPTIONS: `-r', `--pre', `--all', `--pipe' `--match pattern', `--not pattern'

Execute `command arg ...,' suitably modified as described below, for the name of each file and directory in file-or-dir in the specified version, filtered by any `--match' and `--not' operators as described below. This elaborate command is intended to facilitate efficient, open-ended extension of the functions of PRCS. Each directory, whether or not explicitly named in the project, is included once, either in pre- or post-order.

With the `--all' option, command is executed once. Otherwise, it is executed once per file name.

The pattern options filter the selected files. To be selected, the entry in the Files attribute for a given file must satisfy the `--match' pattern (if any) and not satisfy the `--not' pattern, if any. Each pattern is a regular expression; an entry satisfies the pattern if either the name or any of the `:' options matches the pattern.

For each execution of command, PRCS first replaces the following strings wherever they appear in command and in each arg:

{}
Replaced by the name of the file. With the `--all' option, replaced by the sequence of all selected file names, separated by "unquoted blanks" (that is, blanks that divide the replacement string into separate arguments).
{options}
Replaced by a string consisting of all colon-options applicable to the file (see section Files attribute), separated by "quoted blanks" (that is, blanks that do not divide the replacement string into separate arguments). If a directory is not explicitly named in the project file, it is listed with a :implicit-directory option, whether or not it appears separately in the Files attribute. These directories appear whether or not the files containing them were on the command line (otherwise, it would be impossible to get just the directories). The project file is included with the :project-file attribute. With the `--all' option, all of these colon-option strings are concatenated together, with the strings for different files separated by unquoted blanks.
{file}
The name of a file containing the contents of the appropriate version of the file. Unless the internal file identifier is null (which can only happen when there is no `-r' option, so that the working version is specified), this is the name of a temporary file containing a checked-out copy of the appropriate version, which is deleted after command completes. With a null internal file identifier, {file} is the same as {}. It is the empty string for a directory or a file carrying the :symlink option. With the `--all' option, all of these file names are concatenated together, separated by unquoted blanks.

(In contexts where curly braces are special to your shell, you will have to escape them.) After these substitutions, PRCS invokes command, which must be an executable file. It looks for command in the same directories as the shell (using the PATH environment variable). When `--' and what follows are omitted, they default to

-- /bin/echo {}

which simply echoes the names of all files and directories in the selected version, one per line.

One small glitch: prcs execute uses the current directory in effect when it is invoked as the current directory seen by command. This is true, even when the project operand specifies a subdirectory. For example,

% cd /usr/users/foo
% prcs execute D/P -- pwd

will print `/usr/users/foo' once for each file listed in `/usr/users/foo/D/P.prj', and not `/usr/users/foo/D', as the general description of the project operand might otherwise suggest (see section 6.1 Specifying Projects). This allows you to do something like the following:

% ln -s . P-1.0
% tar -cvf P-1.0.tar `prcs execute --not :.*directory P-1.0`

for making tarfiles containing all files in a project in an appropriately named subdirectory for distribution.

If the `--pipe' option is present, then the contents of the file (as would be contained in the file named by `{file}') is supplied as the standard input. The `--pipe' and `--all' options are incompatible. Any arg whose replacement contains unquoted blanks (introduced by the `--all' option) is divided at those blanks into separate arguments (even in the case where substitution results in a null string, that null string will be broken out as a separate argument). Each of the resulting arguments, is passed directly to the program specified by command as a single string, with no further processing by any shell.

With the `--all' option, PRCS will invoke command only once. The order of the lists of arguments replacing each pattern in command is consistent, so that, for example, the options for the first file name in the replacement for `{}' is the first string in the replacement for `{options}'. For example, if a project contains the files `A', `B/Q', and `B/R', then

prcs execute --all . -- foo -a{}-b "{options}"

will execute (in effect) the single command

foo -aA B/Q B/R B-b "" "" "" ":directory"

With the `--pre' (for pre-order) option the directory name is listed first, then the non-directory file names within that directory, then the subdirectories and their contents. Otherwise, subdirectories and their contents are listed first, then the names of its non-directory files, then the name of the directory itself.

With `-n', the command prints the commands that will be executed without actually executing them.

6.16 Deleting Project Versions

Command: prcs delete `-r' version project

Delete the indicated version of project. It will no longer be possible to retrieve the given version. Therefore, this is a command that you should use very sparingly, if at all.

Deleting a version does not necessarily release the space used by the files it contains, since these may be mentioned in other versions. At various times, PRCS will note what space can actually be released and do so.

Minor version numbers increase monotonically, regardless of deletions, and are never re-used.


Go to the first, previous, next, last section, table of contents.