This is update.c in view mode; [Download] [Up]
/*
* Copyright (c) 1992, Brian Berliner and Jeff Polk
* Copyright (c) 1989-1992, Brian Berliner
*
* You may distribute under the terms of the GNU General Public License as
* specified in the README file that comes with the CVS 1.3 kit.
*
* "update" updates the version in the present directory with respect to the RCS
* repository. The present version must have been created by "checkout". The
* user can keep up-to-date by calling "update" whenever he feels like it.
*
* The present version can be committed by "commit", but this keeps the version
* in tact.
*
* Arguments following the options are taken to be file names to be updated,
* rather than updating the entire directory.
*
* Modified or non-existent RCS files are checked out and reported as U
* <user_file>
*
* Modified user files are reported as M <user_file>. If both the RCS file and
* the user file have been modified, the user file is replaced by the result
* of rcsmerge, and a backup file is written for the user in .#file.version.
* If this throws up irreconcilable differences, the file is reported as C
* <user_file>, and as M <user_file> otherwise.
*
* Files added but not yet committed are reported as A <user_file>. Files
* removed but not yet committed are reported as R <user_file>.
*
* If the current directory contains subdirectories that hold concurrent
* versions, these are updated too. If the -d option was specified, new
* directories added to the repository are automatically created and updated
* as well.
*/
#include "cvs.h"
/* rcvs: header */
#include "rcvs.h"
#ifndef lint
static char rcsid[] = "@(#)update.c 1.83 92/04/10";
#endif
#if __STDC__
static int checkout_file (char *file, char *repository, List *entries,
List *srcfiles, Vers_TS *vers_ts, char *update_dir);
static int isemptydir (char *dir);
static int merge_file (char *file, char *repository, List *entries,
Vers_TS *vers, char *update_dir);
static int scratch_file (char *file, char *repository, List * entries,
char *update_dir);
static Dtype update_dirent_proc (char *dir, char *repository, char *update_dir);
static int update_dirleave_proc (char *dir, int err, char *update_dir);
static int update_file_proc (char *file, char *update_dir, char *repository,
List * entries, List * srcfiles);
static int update_filesdone_proc (int err, char *repository, char *update_dir);
static int write_letter (char *file, int letter, char *update_dir);
static void ignore_files (List * ilist, char *update_dir);
static void join_file (char *file, List *srcfiles, Vers_TS *vers_ts,
char *update_dir);
#else
static int update_file_proc ();
static int update_filesdone_proc ();
static Dtype update_dirent_proc ();
static int update_dirleave_proc ();
static int isemptydir ();
static int scratch_file ();
static int checkout_file ();
static int write_letter ();
static int merge_file ();
static void ignore_files ();
static void join_file ();
#endif /* __STDC__ */
static char *options = NULL;
static char *tag = NULL;
static char *date = NULL;
static char *join_rev1, *date_rev1;
static char *join_rev2, *date_rev2;
static int aflag = 0;
static int force_tag_match = 1;
static int update_build_dirs = 0;
static int update_prune_dirs = 0;
static int pipeout = 0;
static List *ignlist = (List *) NULL;
static char *update_usage[] =
{
"Usage:\n %s %s [-APQdflRpq] [-k kopt] [-r rev|-D date] [-j rev] [-I ign] [files...]\n",
"\t-A\tReset any sticky tags/date/kopts.\n",
"\t-P\tPrune empty directories.\n",
"\t-Q\tReally quiet.\n",
"\t-d\tBuild directories, like checkout does.\n",
"\t-f\tForce a head revision match if tag/date not found.\n",
"\t-l\tLocal directory only, no recursion.\n",
"\t-R\tProcess directories recursively.\n",
"\t-p\tSend updates to standard output.\n",
"\t-q\tSomewhat quiet.\n",
"\t-k kopt\tUse RCS kopt -k option on checkout.\n",
"\t-r rev\tUpdate using specified revision/tag.\n",
"\t-D date\tSet date to update from.\n",
"\t-j rev\tMerge in changes made between current revision and rev.\n",
"\t-I ign\tMore files to ignore (! to reset).\n",
NULL
};
/*
* update is the argv,argc based front end for arg parsing
*/
int
update (argc, argv)
int argc;
char *argv[];
{
int c, err;
int local = 0; /* recursive by default */
int which; /* where to look for files and dirs */
if (argc == -1)
usage (update_usage);
ign_setup ();
/* parse the args */
optind = 1;
while ((c = gnu_getopt (argc, argv, "ApPflRQqdk:r:D:j:I:")) != -1)
{
/* rcvs: quietly go through all options */
if (rcvs_parse_opt)
continue;
switch (c)
{
case 'A':
aflag = 1;
break;
case 'I':
ign_add (optarg, 0);
break;
case 'k':
if (options)
free (options);
options = RCS_check_kflag (optarg);
break;
case 'l':
local = 1;
break;
case 'R':
local = 0;
break;
case 'Q':
really_quiet = 1;
/* FALL THROUGH */
case 'q':
quiet = 1;
break;
case 'd':
update_build_dirs = 1;
break;
case 'f':
force_tag_match = 0;
break;
case 'r':
tag = optarg;
break;
case 'D':
date = Make_Date (optarg);
break;
case 'P':
update_prune_dirs = 1;
break;
case 'p':
pipeout = 1;
noexec = 1; /* so no locks will be created */
break;
case 'j':
if (join_rev2)
error (1, 0, "only two -j options can be specified");
if (join_rev1)
join_rev2 = optarg;
else
join_rev1 = optarg;
break;
case '?':
default:
usage (update_usage);
break;
}
}
argc -= optind;
argv += optind;
/* rcvs: return to rcvs_main after parsing options */
if (rcvs_parse_opt)
{
rcvs_cmd_optind = optind;
return (0);
}
/*
* If we are updating the entire directory (for real) and building dirs
* as we go, we make sure there is no static entries file and write the
* tag file as appropriate
*/
if (argc <= 0 && !pipeout)
{
if (update_build_dirs)
(void) unlink_file (CVSADM_ENTSTAT);
/* keep the CVS/Tag file current with the specified arguments */
if (aflag || tag || date)
WriteTag ((char *) NULL, tag, date);
}
/* look for files/dirs locally and in the repository */
which = W_LOCAL | W_REPOS;
/* look in the attic too if a tag or date is specified */
if (tag != NULL || date != NULL)
which |= W_ATTIC;
/* call the command line interface */
err = do_update (argc, argv, options, tag, date, force_tag_match,
local, update_build_dirs, aflag, update_prune_dirs,
pipeout, which, join_rev1, join_rev2, (char *) NULL);
/* free the space Make_Date allocated if necessary */
if (date != NULL)
free (date);
return (err);
}
/*
* Command line interface to update (used by checkout)
*/
int
do_update (argc, argv, xoptions, xtag, xdate, xforce, local, xbuild, xaflag,
xprune, xpipeout, which, xjoin_rev1, xjoin_rev2, preload_update_dir)
int argc;
char *argv[];
char *xoptions;
char *xtag;
char *xdate;
int xforce;
int local;
int xbuild;
int xaflag;
int xprune;
int xpipeout;
int which;
char *xjoin_rev1;
char *xjoin_rev2;
char *preload_update_dir;
{
int err = 0;
char *cp;
/* fill in the statics */
options = xoptions;
tag = xtag;
date = xdate;
force_tag_match = xforce;
update_build_dirs = xbuild;
aflag = xaflag;
update_prune_dirs = xprune;
pipeout = xpipeout;
/* setup the join support */
join_rev1 = xjoin_rev1;
join_rev2 = xjoin_rev2;
if (join_rev1 && (cp = index (join_rev1, ':')) != NULL)
{
*cp++ = '\0';
date_rev1 = Make_Date (cp);
}
else
date_rev1 = (char *) NULL;
if (join_rev2 && (cp = index (join_rev2, ':')) != NULL)
{
*cp++ = '\0';
date_rev2 = Make_Date (cp);
}
else
date_rev2 = (char *) NULL;
/* call the recursion processor */
err = start_recursion (update_file_proc, update_filesdone_proc,
update_dirent_proc, update_dirleave_proc,
argc, argv, local, which, aflag, 1,
preload_update_dir, 1);
return (err);
}
/*
* This is the callback proc for update. It is called for each file in each
* directory by the recursion code. The current directory is the local
* instantiation. file is the file name we are to operate on. update_dir is
* set to the path relative to where we started (for pretty printing).
* repository is the repository. entries and srcfiles are the pre-parsed
* entries and source control files.
*
* This routine decides what needs to be done for each file and does the
* appropriate magic for checkout
*/
static int
update_file_proc (file, update_dir, repository, entries, srcfiles)
char *file;
char *update_dir;
char *repository;
List *entries;
List *srcfiles;
{
int retval;
Ctype status;
Vers_TS *vers;
status = Classify_File (file, tag, date, options, force_tag_match,
aflag, repository, entries, srcfiles, &vers);
if (pipeout)
{
/*
* We just return success without doing anything if any of the really
* funky cases occur
*
* If there is still a valid RCS file, do a regular checkout type
* operation
*/
switch (status)
{
case T_UNKNOWN: /* unknown file was explicitly asked
* about */
case T_REMOVE_ENTRY: /* needs to be un-registered */
case T_ADDED: /* added but not committed */
retval = 0;
break;
case T_CONFLICT: /* old punt-type errors */
retval = 1;
break;
case T_UPTODATE: /* file was already up-to-date */
case T_NEEDS_MERGE: /* needs merging */
case T_MODIFIED: /* locally modified */
case T_REMOVED: /* removed but not committed */
case T_CHECKOUT: /* needs checkout */
retval = checkout_file (file, repository, entries, srcfiles,
vers, update_dir);
break;
default: /* can't ever happen :-) */
error (0, 0,
"unknown file status %d for file %s", status, file);
retval = 0;
break;
}
}
else
{
switch (status)
{
case T_UNKNOWN: /* unknown file was explicitly asked
* about */
case T_UPTODATE: /* file was already up-to-date */
retval = 0;
break;
case T_CONFLICT: /* old punt-type errors */
retval = 1;
break;
case T_NEEDS_MERGE: /* needs merging */
retval = merge_file (file, repository, entries,
vers, update_dir);
break;
case T_MODIFIED: /* locally modified */
retval = write_letter (file, 'M', update_dir);
break;
case T_CHECKOUT: /* needs checkout */
retval = checkout_file (file, repository, entries, srcfiles,
vers, update_dir);
break;
case T_ADDED: /* added but not committed */
retval = write_letter (file, 'A', update_dir);
break;
case T_REMOVED: /* removed but not committed */
retval = write_letter (file, 'R', update_dir);
break;
case T_REMOVE_ENTRY: /* needs to be un-registered */
retval = scratch_file (file, repository, entries, update_dir);
break;
default: /* can't ever happen :-) */
error (0, 0,
"unknown file status %d for file %s", status, file);
retval = 0;
break;
}
}
/* only try to join if things have gone well thus far */
if (retval == 0 && join_rev1)
join_file (file, srcfiles, vers, update_dir);
/* if this directory has an ignore list, add this file to it */
if (ignlist)
{
Node *p;
p = getnode ();
p->type = FILES;
p->key = xstrdup (file);
(void) addnode (ignlist, p);
}
freevers_ts (&vers);
return (retval);
}
/*
* update_filesdone_proc () is used
*/
/* ARGSUSED */
static int
update_filesdone_proc (err, repository, update_dir)
int err;
char *repository;
char *update_dir;
{
/* if this directory has an ignore list, process it then free it */
if (ignlist)
{
ignore_files (ignlist, update_dir);
dellist (&ignlist);
}
/* Clean up CVS admin dirs if we are export */
if (strcmp (command_name, "export") == 0)
{
run_setup ("%s -fr", RM);
run_arg (CVSADM);
(void) run_exec (RUN_TTY, RUN_TTY, RUN_TTY, RUN_NORMAL);
}
return (err);
}
/*
* update_dirent_proc () is called back by the recursion processor before a
* sub-directory is processed for update. In this case, update_dirent proc
* will probably create the directory unless -d isn't specified and this is a
* new directory. A return code of 0 indicates the directory should be
* processed by the recursion code. A return of non-zero indicates the
* recursion code should skip this directory.
*/
static Dtype
update_dirent_proc (dir, repository, update_dir)
char *dir;
char *repository;
char *update_dir;
{
if (!isdir (dir))
{
/* if we aren't building dirs, blow it off */
if (!update_build_dirs)
return (R_SKIP_ALL);
if (noexec)
{
/* ignore the missing dir if -n is specified */
error (0, 0, "New directory `%s' -- ignored", dir);
return (R_SKIP_ALL);
}
else
{
/* otherwise, create the dir and appropriate adm files */
make_directory (dir);
Create_Admin (dir, repository, tag, date);
}
}
/* rcvs: */
else if ((rcvs_inshell && rcvs_Copt_change_repos) || (rcvs_copt_change_repos))
rcvs_remake_adm (dir, repository);
/*
* If we are building dirs and not going to stdout, we make sure there is
* no static entries file and write the tag file as appropriate
*/
if (!pipeout)
{
if (update_build_dirs)
{
char tmp[PATH_MAX];
(void) sprintf (tmp, "%s/%s", dir, CVSADM_ENTSTAT);
(void) unlink_file (tmp);
}
/* keep the CVS/Tag file current with the specified arguments */
if (aflag || tag || date)
WriteTag (dir, tag, date);
/* initialize the ignore list for this directory */
ignlist = getlist ();
}
/* print the warm fuzzy message */
if (!quiet && !rcvs_sync) /* rcvs: */
error (0, 0, "Updating %s", update_dir);
return (R_PROCESS);
}
/*
* update_dirleave_proc () is called back by the recursion code upon leaving
* a directory. It will prune empty directories if needed and will execute
* any appropriate update programs.
*/
/* ARGSUSED */
static int
update_dirleave_proc (dir, err, update_dir)
char *dir;
int err;
char *update_dir;
{
FILE *fp;
/* run the update_prog if there is one */
if (err == 0 && !pipeout && !noexec &&
(fp = fopen (CVSADM_UPROG, "r")) != NULL)
{
char *cp;
char *repository;
char line[MAXLINELEN];
repository = Name_Repository ((char *) NULL, update_dir);
if (fgets (line, sizeof (line), fp) != NULL)
{
if ((cp = rindex (line, '\n')) != NULL)
*cp = '\0';
run_setup ("%s %s", line, repository);
(void) printf ("%s %s: Executing '", program_name, command_name);
run_print (stdout);
(void) printf ("'\n");
(void) run_exec (RUN_TTY, RUN_TTY, RUN_TTY, RUN_NORMAL);
}
(void) fclose (fp);
free (repository);
}
/* Clean up CVS admin dirs if we are export */
if (strcmp (command_name, "export") == 0)
{
run_setup ("%s -fr", RM);
run_arg (CVSADM);
(void) run_exec (RUN_TTY, RUN_TTY, RUN_TTY, RUN_NORMAL);
}
/* Prune empty dirs on the way out - if necessary */
(void) chdir ("..");
if (update_prune_dirs && isemptydir (dir))
{
run_setup ("%s -fr", RM);
run_arg (dir);
(void) run_exec (RUN_TTY, RUN_TTY, RUN_TTY, RUN_NORMAL);
}
return (err);
}
/*
* Returns 1 if the argument directory is completely empty, other than the
* existence of the CVS directory entry. Zero otherwise.
*/
static int
isemptydir (dir)
char *dir;
{
DIR *dirp;
struct direct *dp;
if ((dirp = opendir (dir)) == NULL)
{
error (0, 0, "cannot open directory %s for empty check", dir);
return (0);
}
while ((dp = readdir (dirp)) != NULL)
{
if (strcmp (dp->d_name, ".") != 0 && strcmp (dp->d_name, "..") != 0 &&
strcmp (dp->d_name, CVSADM) != 0 &&
strcmp (dp->d_name, OCVSADM) != 0)
{
(void) closedir (dirp);
return (0);
}
}
(void) closedir (dirp);
return (1);
}
/*
* scratch the Entries file entry associated with a file
*/
static int
scratch_file (file, repository, entries, update_dir)
char *file;
char *repository;
List *entries;
char *update_dir;
{
history_write ('W', update_dir, "", file, repository);
Scratch_Entry (entries, file);
(void) unlink_file (file);
return (0);
}
/*
* check out a file - essentially returns the result of the fork on "co".
*/
static int
checkout_file (file, repository, entries, srcfiles, vers_ts, update_dir)
char *file;
char *repository;
List *entries;
List *srcfiles;
Vers_TS *vers_ts;
char *update_dir;
{
char backup[PATH_MAX];
int set_time, retval = 0;
int retcode = 0;
/* rcvs: do not actually checkout files for 'cvs -S', only module
list are needed */
if ( rcvs_sync && rcvs_do_rdist )
return;
/* don't screw with backup files if we're going to stdout */
if (!pipeout)
{
(void) sprintf (backup, "%s/%s%s", CVSADM, CVSPREFIX, file);
if (isfile (file))
rename_file (file, backup);
else
(void) unlink_file (backup);
}
run_setup ("%s%s -q -r%s %s", Rcsbin, RCS_CO, vers_ts->vn_rcs,
vers_ts->options);
/*
* if we are checking out to stdout, print a nice message to stderr, and
* add the -p flag to the command
*/
if (pipeout)
{
run_arg ("-p");
if (!quiet)
{
(void) fprintf (stderr, "===================================================================\n");
if (update_dir[0])
(void) fprintf (stderr, "Checking out %s/%s\n",
update_dir, file);
else
(void) fprintf (stderr, "Checking out %s\n", file);
(void) fprintf (stderr, "RCS: %s\n", vers_ts->srcfile->path);
(void) fprintf (stderr, "VERS: %s\n", vers_ts->vn_rcs);
(void) fprintf (stderr, "***************\n");
}
}
/* tack on the rcs and maybe the user file */
run_arg (vers_ts->srcfile->path);
if (!pipeout)
run_arg (file);
if ((retcode = run_exec (RUN_TTY, RUN_TTY, RUN_TTY,
(pipeout ? (RUN_NORMAL|RUN_REALLY) : RUN_NORMAL))) == 0)
{
if (!pipeout)
{
Vers_TS *xvers_ts;
if (cvswrite == TRUE)
xchmod (file, 1);
/* set the time from the RCS file iff it was unknown before */
if (vers_ts->vn_user == NULL ||
strncmp (vers_ts->ts_rcs, "Initial", 7) == 0)
{
set_time = 1;
}
else
set_time = 0;
xvers_ts = Version_TS (repository, options, tag, date, file,
force_tag_match, set_time, entries, srcfiles);
if (strcmp (xvers_ts->options, "-V4") == 0)
xvers_ts->options[0] = '\0';
Register (entries, file, xvers_ts->vn_rcs, xvers_ts->ts_user,
xvers_ts->options, xvers_ts->tag, xvers_ts->date);
/* fix up the vers structure, in case it is used by join */
if (join_rev1)
{
if (vers_ts->vn_user != NULL)
free (vers_ts->vn_user);
if (vers_ts->vn_rcs != NULL)
free (vers_ts->vn_rcs);
vers_ts->vn_user = xstrdup (xvers_ts->vn_rcs);
vers_ts->vn_rcs = xstrdup (xvers_ts->vn_rcs);
}
/* If this is really Update and not Checkout, recode history */
if (strcmp (command_name, "update") == 0)
history_write ('U', update_dir, xvers_ts->vn_rcs, file,
repository);
freevers_ts (&xvers_ts);
if (!really_quiet)
{
if (update_dir[0])
(void) printf ("U %s/%s\n", update_dir, file);
else
(void) printf ("U %s\n", file);
}
}
}
else
{
int old_errno = errno; /* save errno value over the rename */
if (!pipeout && isfile (backup))
rename_file (backup, file);
error (retcode == -1 ? 1 : 0, retcode == -1 ? old_errno : 0,
"could not check out %s", file);
retval = retcode;
}
if (!pipeout)
(void) unlink_file (backup);
return (retval);
}
/*
* Several of the types we process only print a bit of information consisting
* of a single letter and the name.
*/
static int
write_letter (file, letter, update_dir)
char *file;
char letter;
char *update_dir;
{
if (!really_quiet)
{
if (update_dir[0])
(void) printf ("%c %s/%s\n", letter, update_dir, file);
else
(void) printf ("%c %s\n", letter, file);
}
return (0);
}
/*
* Do all the magic associated with a file which needs to be merged
*/
static int
merge_file (file, repository, entries, vers, update_dir)
char *file;
char *repository;
List *entries;
Vers_TS *vers;
char *update_dir;
{
char user[PATH_MAX];
char backup[PATH_MAX];
int status;
int retcode = 0;
/*
* The users currently modified file is moved to a backup file name
* ".#filename.version", so that it will stay around for a few days
* before being automatically removed by some cron daemon. The "version"
* is the version of the file that the user was most up-to-date with
* before the merge.
*/
(void) sprintf (backup, "%s%s.%s", BAKPREFIX, file, vers->vn_user);
if (update_dir[0])
(void) sprintf (user, "%s/%s", update_dir, file);
else
(void) strcpy (user, file);
(void) unlink_file (backup);
copy_file (file, backup);
xchmod (file, 1);
/* XXX - Do merge by hand instead of using rcsmerge, due to -k handling */
run_setup ("%s%s %s -r%s -r%s", Rcsbin, RCS_RCSMERGE, vers->options,
vers->vn_user, vers->vn_rcs);
run_arg (vers->srcfile->path);
status = run_exec (RUN_TTY, RUN_TTY, RUN_TTY, RUN_NORMAL);
if (status != 0
#ifdef HAVE_RCS5
&& status != 1
#endif
)
{
error (0, status == -1 ? errno : 0,
"could not merge revision %s of %s", vers->vn_user, user);
error (status == -1 ? 1 : 0, 0, "restoring %s from backup file %s",
user, backup);
rename_file (backup, file);
return (1);
}
/* XXX - Might want to make sure that rcsmerge changed the file */
if (strcmp (vers->options, "-V4") == 0)
vers->options[0] = '\0';
Register (entries, file, vers->vn_rcs, vers->ts_rcs, vers->options,
vers->tag, vers->date);
/* fix up the vers structure, in case it is used by join */
if (join_rev1)
{
if (vers->vn_user != NULL)
free (vers->vn_user);
vers->vn_user = xstrdup (vers->vn_rcs);
}
/* possibly run GREP to see if there appear to be conflicts in the file */
run_setup ("%s -s", GREP);
run_arg (RCS_MERGE_PAT);
run_arg (file);
if (status == 1 ||
(retcode = run_exec (RUN_TTY, RUN_TTY, RUN_TTY, RUN_NORMAL)) == 0)
{
if (!noexec)
error (0, 0, "conflicts found in %s", user);
if (!really_quiet)
(void) printf ("C %s\n", user);
history_write ('C', update_dir, vers->vn_rcs, file, repository);
}
else if (retcode == -1)
{
error (1, errno, "fork failed while examining update of %s", user);
}
else
{
if (!really_quiet)
(void) printf ("M %s\n", user);
history_write ('G', update_dir, vers->vn_rcs, file, repository);
}
return (0);
}
/*
* Do all the magic associated with a file which needs to be joined
* (-j option)
*/
static void
join_file (file, srcfiles, vers, update_dir)
char *file;
List *srcfiles;
Vers_TS *vers;
char *update_dir;
{
char user[PATH_MAX];
char backup[PATH_MAX];
char *rev, *baserev;
char *options;
int status;
/* determine if we need to do anything at all */
if (vers->vn_user == NULL || vers->srcfile == NULL ||
vers->srcfile->path == NULL)
{
return;
}
/* special handling when two revisions are specified */
if (join_rev1 && join_rev2)
{
rev = RCS_getversion (vers->srcfile, join_rev2, date_rev2, 1);
if (rev == NULL)
{
if (!quiet && date_rev2 == NULL)
error (0, 0,
"cannot find revision %s in file %s", join_rev2, file);
return;
}
baserev = RCS_getversion (vers->srcfile, join_rev1, date_rev1, 1);
if (baserev == NULL)
{
if (!quiet && date_rev1 == NULL)
error (0, 0,
"cannot find revision %s in file %s", join_rev1, file);
free (rev);
return;
}
/*
* nothing to do if:
* second revision matches our BASE revision (vn_user) &&
* both revisions are on the same branch
*/
if (strcmp (vers->vn_user, rev) == 0 &&
numdots (baserev) == numdots (rev))
{
/* might be the same branch. take a real look */
char *dot = rindex (baserev, '.');
int len = (dot - baserev) + 1;
if (strncmp (baserev, rev, len) == 0)
return;
}
}
else
{
rev = RCS_getversion (vers->srcfile, join_rev1, date_rev1, 1);
if (rev == NULL)
return;
if (strcmp (rev, vers->vn_user) == 0) /* no merge necessary */
{
free (rev);
return;
}
baserev = RCS_whatbranch (file, join_rev1, srcfiles);
if (baserev)
{
char *cp;
/* we get a branch -- turn it into a revision, or NULL if trunk */
if ((cp = rindex (baserev, '.')) == NULL)
{
free (baserev);
baserev = (char *) NULL;
}
else
*cp = '\0';
}
}
if (baserev && strcmp (baserev, rev) == 0)
{
/* they match -> nothing to do */
free (rev);
free (baserev);
return;
}
/* OK, so we have a revision and possibly a base revision; continue on */
/*
* The users currently modified file is moved to a backup file name
* ".#filename.version", so that it will stay around for a few days
* before being automatically removed by some cron daemon. The "version"
* is the version of the file that the user was most up-to-date with
* before the merge.
*/
(void) sprintf (backup, "%s%s.%s", BAKPREFIX, file, vers->vn_user);
if (update_dir[0])
(void) sprintf (user, "%s/%s", update_dir, file);
else
(void) strcpy (user, file);
(void) unlink_file (backup);
copy_file (file, backup);
xchmod (file, 1);
options = vers->options;
#ifdef HAVE_RCS5
if (*options == '\0')
options = "-kk"; /* to ignore keyword expansions */
#endif
/* XXX - Do merge by hand instead of using rcsmerge, due to -k handling */
run_setup ("%s%s %s %s%s -r%s", Rcsbin, RCS_RCSMERGE, options,
baserev ? "-r" : "", baserev ? baserev : "", rev);
run_arg (vers->srcfile->path);
status = run_exec (RUN_TTY, RUN_TTY, RUN_TTY, RUN_NORMAL);
if (status != 0
#ifdef HAVE_RCS5
&& status != 1
#endif
)
{
error (0, status == -1 ? errno : 0,
"could not merge revision %s of %s", rev, user);
error (status == -1 ? 1 : 0, 0, "restoring %s from backup file %s",
user, backup);
rename_file (backup, file);
}
free (rev);
if (baserev)
free (baserev);
return;
}
/*
* Process the current directory, looking for files not in ILIST and not on
* the global ignore list for this directory.
*/
static void
ignore_files (ilist, update_dir)
List *ilist;
char *update_dir;
{
DIR *dirp;
struct direct *dp;
struct stat sb;
char *file;
char *xdir;
/* we get called with update_dir set to "." sometimes... strip it */
if (strcmp (update_dir, ".") == 0)
xdir = "";
else
xdir = update_dir;
dirp = opendir (".");
if (dirp == NULL)
return;
ign_add_file (CVSDOTIGNORE, 1);
while ((dp = readdir (dirp)) != NULL)
{
file = dp->d_name;
if (strcmp (file, ".") == 0 || strcmp (file, "..") == 0)
continue;
if (findnode (ilist, file) != NULL)
continue;
if (lstat (file, &sb) != -1)
{
if (S_ISDIR (sb.st_mode))
continue;
#ifdef S_IFLNK
if (S_ISLNK (sb.st_mode))
continue;
#endif
}
if (ign_name (file))
continue;
(void) write_letter (file, '?', xdir);
}
(void) closedir (dirp);
}
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.