1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
|
/*
* 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.4 kit.
*
* The functions in this file provide an interface for performing
* operations directly on RCS files.
*/
#include "cvs.h"
#include <assert.h>
/* This file, rcs.h, and rcs.c, are intended to define our interface
to RCS files. As of July, 1996, there are still a few places that
still exec RCS commands directly. The intended long-term direction
is to have CVS access RCS files via an RCS library (rcs.c can be
considered a start at one), for performance, cleanliness (CVS has
some awful hacks to work around RCS behaviors which don't make
sense for CVS), installation hassles, ease of implementing the CVS
server (I don't think that the output-out-of-order bug can be
completely fixed as long as CVS calls RCS), and perhaps other
reasons.
Whether there will also be a version of RCS which uses this
library, or whether the library will be packaged for uses beyond
CVS or RCS (many people would like such a thing) is an open
question. Some considerations:
1. An RCS library for CVS must have the capabilities of the
existing CVS code which accesses RCS files. In particular, simple
approaches will often be slow.
2. An RCS library should not use the code from the current RCS
(5.7 and its ancestors). The code has many problems. Too few
comments, too many layers of abstraction, too many global variables
(the correct number for a library is zero), too much intricately
interwoven functionality, and too many clever hacks. Paul Eggert,
the current RCS maintainer, agrees.
3. More work needs to be done in terms of separating out the RCS
library from the rest of CVS (for example, cvs_output should be
replaced by a callback, and the declarations should be centralized
into rcs.h, and probably other such cleanups).
4. To be useful for RCS and perhaps for other uses, the library
may need features beyond those needed by CVS.
5. Any changes to the RCS file format *must* be compatible. Many,
many tools (not just CVS and RCS) can at least import this format.
RCS and CVS must preserve the current ability to import/export it
(preferably improved--magic branches are currently a roadblock).
See doc/RCSFILES in the CVS distribution for documentation of this
file format.
On somewhat related notes:
1. A library for diff is an obvious idea. The one thing which I'm
not so sure about is that I think CVS probably wants the ability to
allow arbitrarily-bizarre (and possibly customized for particular
file formats) external diff programs.
2. A library for patch is another such idea. CVS's needs are
smaller than the functionality of the standalone patch program (it
only calls patch in the client, and only needs to be able to patch
unmodified versions, which is something that RCS_deltas already
does in a different context). But it is silly for CVS to be making
people install patch as well as CVS for such a simple purpose. */
/* For RCS file PATH, make symbolic tag TAG point to revision REV.
This validates that TAG is OK for a user to use. Return value is
-1 for error (and errno is set to indicate the error), positive for
error (and an error message has been printed), or zero for success. */
int
RCS_exec_settag(path, tag, rev)
const char *path;
const char *tag;
const char *rev;
{
run_setup ("%s%s -x,v/ -q -N%s:%s", Rcsbin, RCS, tag, rev);
run_arg (path);
return run_exec (RUN_TTY, RUN_TTY, RUN_TTY, RUN_NORMAL);
}
/* NOERR is 1 to suppress errors--FIXME it would
be better to avoid the errors or some cleaner solution. */
int
RCS_exec_deltag(path, tag, noerr)
const char *path;
const char *tag;
int noerr;
{
run_setup ("%s%s -x,v/ -q -N%s", Rcsbin, RCS, tag);
run_arg (path);
return run_exec (RUN_TTY, RUN_TTY, noerr ? DEVNULL : RUN_TTY, RUN_NORMAL);
}
/* set RCS branch to REV */
int
RCS_exec_setbranch(path, rev)
const char *path;
const char *rev;
{
run_setup ("%s%s -x,v/ -q -b%s", Rcsbin, RCS, rev ? rev : "");
run_arg (path);
return run_exec (RUN_TTY, RUN_TTY, RUN_TTY, RUN_NORMAL);
}
/* Lock revision REV. NOERR is 1 to suppress errors--FIXME it would
be better to avoid the errors or some cleaner solution. */
int
RCS_exec_lock(path, rev, noerr)
const char *path;
const char *rev;
int noerr;
{
run_setup ("%s%s -x,v/ -q -l%s", Rcsbin, RCS, rev ? rev : "");
run_arg (path);
return run_exec (RUN_TTY, RUN_TTY, noerr ? DEVNULL : RUN_TTY, RUN_NORMAL);
}
/* Unlock revision REV. NOERR is 1 to suppress errors--FIXME it would
be better to avoid the errors or some cleaner solution. */
int
RCS_exec_unlock(path, rev, noerr)
const char *path;
const char *rev;
int noerr;
{
run_setup ("%s%s -x,v/ -q -u%s", Rcsbin, RCS, rev ? rev : "");
run_arg (path);
return run_exec (RUN_TTY, RUN_TTY, noerr ? DEVNULL : RUN_TTY, RUN_NORMAL);
}
/* Merge revisions REV1 and REV2. */
int
RCS_merge(path, options, rev1, rev2)
const char *path;
const char *options;
const char *rev1;
const char *rev2;
{
int status;
/* XXX - Do merge by hand instead of using rcsmerge, due to -k handling */
run_setup ("%s%s -x,v/ %s -r%s -r%s %s", Rcsbin, RCS_RCSMERGE,
options, rev1, rev2, path);
status = run_exec (RUN_TTY, RUN_TTY, RUN_TTY, RUN_NORMAL);
#ifndef HAVE_RCS5
if (status == 0)
{
error (1, 0, "CVS no longer supports RCS versions older than RCS5");
/* This case needs to call file_has_markers to see if the file
contains conflict indicators. But is anyone using the !HAVE_RCS5
code any more? */
}
#endif
return status;
}
/* Check in to RCSFILE with revision REV (which must be greater than the
largest revision) and message MESSAGE (which is checked for legality).
If FLAGS & RCS_FLAGS_DEAD, check in a dead revision. If FLAGS &
RCS_FLAGS_QUIET, tell ci to be quiet. If FLAGS & RCS_FLAGS_MODTIME,
use the working file's modification time for the checkin time.
WORKFILE is the working file to check in from, or NULL to use the usual
RCS rules for deriving it from the RCSFILE.
Return value is -1 for error (and errno is set to indicate the
error), positive for error (and an error message has been printed),
or zero for success. */
int
RCS_checkin (rcsfile, workfile, message, rev, flags)
char *rcsfile;
char *workfile;
char *message;
char *rev;
int flags;
{
/* The desired behavior regarding permissions is to preserve the
permissions on RCSFILE if it already exists. Based on looking
at the RCS 5.7 source, it would appear that RCS_CI does this
except when it is creating RCSFILE (reasonable), or when
RCSFILE was created with rcs -i (this is strange, and quite
possibly unintentional). In those two cases it copies the
permissions from the workfile.
Anyway, the fix is simple enough: we preserve the mode ourself. */
struct stat sb;
int fix_mode = 1;
int retval;
if (CVS_STAT (rcsfile, &sb) < 0)
{
fix_mode = 0;
if (!existence_error (errno))
error (0, errno, "warning: cannot stat %s", rcsfile);
}
run_setup ("%s%s -x,v/ -f %s%s", Rcsbin, RCS_CI,
rev ? "-r" : "", rev ? rev : "");
if (flags & RCS_FLAGS_DEAD)
run_arg ("-sdead");
if (flags & RCS_FLAGS_QUIET)
run_arg ("-q");
if (flags & RCS_FLAGS_MODTIME)
run_arg ("-d");
run_args ("-m%s", make_message_rcslegal (message));
if (workfile != NULL)
run_arg (workfile);
run_arg (rcsfile);
retval = run_exec (RUN_TTY, RUN_TTY, RUN_TTY, RUN_NORMAL);
if (retval == 0 && fix_mode)
{
if (chmod (rcsfile, sb.st_mode) < 0)
error (0, errno, "warning: cannot change permissions on %s",
rcsfile);
}
return retval;
}
|
