File: | src/usr.bin/cvs/rcs.c |
Warning: | line 1047, column 16 Use of memory after it is freed |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: rcs.c,v 1.320 2020/10/19 19:51:20 naddy Exp $ */ | |||
2 | /* | |||
3 | * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org> | |||
4 | * All rights reserved. | |||
5 | * | |||
6 | * Redistribution and use in source and binary forms, with or without | |||
7 | * modification, are permitted provided that the following conditions | |||
8 | * are met: | |||
9 | * | |||
10 | * 1. Redistributions of source code must retain the above copyright | |||
11 | * notice, this list of conditions and the following disclaimer. | |||
12 | * 2. The name of the author may not be used to endorse or promote products | |||
13 | * derived from this software without specific prior written permission. | |||
14 | * | |||
15 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, | |||
16 | * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY | |||
17 | * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL | |||
18 | * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | |||
19 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |||
20 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; | |||
21 | * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | |||
22 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR | |||
23 | * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF | |||
24 | * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |||
25 | */ | |||
26 | ||||
27 | #include <sys/stat.h> | |||
28 | ||||
29 | #include <ctype.h> | |||
30 | #include <errno(*__errno()).h> | |||
31 | #include <libgen.h> | |||
32 | #include <pwd.h> | |||
33 | #include <stdlib.h> | |||
34 | #include <string.h> | |||
35 | #include <unistd.h> | |||
36 | ||||
37 | #include "atomicio.h" | |||
38 | #include "cvs.h" | |||
39 | #include "diff.h" | |||
40 | #include "rcs.h" | |||
41 | #include "rcsparse.h" | |||
42 | ||||
43 | #define MINIMUM(a, b)(((a) < (b)) ? (a) : (b)) (((a) < (b)) ? (a) : (b)) | |||
44 | ||||
45 | #define RCS_KWEXP_SIZE1024 1024 | |||
46 | ||||
47 | #define ANNOTATE_NEVER0 0 | |||
48 | #define ANNOTATE_NOW1 1 | |||
49 | #define ANNOTATE_LATER2 2 | |||
50 | ||||
51 | /* invalid characters in RCS symbol names */ | |||
52 | static const char rcs_sym_invch[] = RCS_SYM_INVALCHAR"$,.:;@"; | |||
53 | ||||
54 | /* comment leaders, depending on the file's suffix */ | |||
55 | static const struct rcs_comment { | |||
56 | const char *rc_suffix; | |||
57 | const char *rc_cstr; | |||
58 | } rcs_comments[] = { | |||
59 | { "1", ".\\\" " }, | |||
60 | { "2", ".\\\" " }, | |||
61 | { "3", ".\\\" " }, | |||
62 | { "4", ".\\\" " }, | |||
63 | { "5", ".\\\" " }, | |||
64 | { "6", ".\\\" " }, | |||
65 | { "7", ".\\\" " }, | |||
66 | { "8", ".\\\" " }, | |||
67 | { "9", ".\\\" " }, | |||
68 | { "a", "-- " }, /* Ada */ | |||
69 | { "ada", "-- " }, | |||
70 | { "adb", "-- " }, | |||
71 | { "asm", ";; " }, /* assembler (MS-DOS) */ | |||
72 | { "ads", "-- " }, /* Ada */ | |||
73 | { "bat", ":: " }, /* batch (MS-DOS) */ | |||
74 | { "body", "-- " }, /* Ada */ | |||
75 | { "c", " * " }, /* C */ | |||
76 | { "c++", "// " }, /* C++ */ | |||
77 | { "cc", "// " }, | |||
78 | { "cpp", "// " }, | |||
79 | { "cxx", "// " }, | |||
80 | { "m", "// " }, /* Objective-C */ | |||
81 | { "cl", ";;; " }, /* Common Lisp */ | |||
82 | { "cmd", ":: " }, /* command (OS/2) */ | |||
83 | { "cmf", "c " }, /* CM Fortran */ | |||
84 | { "csh", "# " }, /* shell */ | |||
85 | { "e", "# " }, /* efl */ | |||
86 | { "epsf", "% " }, /* encapsulated postscript */ | |||
87 | { "epsi", "% " }, /* encapsulated postscript */ | |||
88 | { "el", "; " }, /* Emacs Lisp */ | |||
89 | { "f", "c " }, /* Fortran */ | |||
90 | { "for", "c " }, | |||
91 | { "h", " * " }, /* C-header */ | |||
92 | { "hh", "// " }, /* C++ header */ | |||
93 | { "hpp", "// " }, | |||
94 | { "hxx", "// " }, | |||
95 | { "in", "# " }, /* for Makefile.in */ | |||
96 | { "l", " * " }, /* lex */ | |||
97 | { "mac", ";; " }, /* macro (DEC-10, MS-DOS, PDP-11, VMS, etc) */ | |||
98 | { "mak", "# " }, /* makefile, e.g. Visual C++ */ | |||
99 | { "me", ".\\\" " }, /* me-macros t/nroff */ | |||
100 | { "ml", "; " }, /* mocklisp */ | |||
101 | { "mm", ".\\\" " }, /* mm-macros t/nroff */ | |||
102 | { "ms", ".\\\" " }, /* ms-macros t/nroff */ | |||
103 | { "man", ".\\\" " }, /* man-macros t/nroff */ | |||
104 | { "p", " * " }, /* pascal */ | |||
105 | { "pas", " * " }, | |||
106 | { "pl", "# " }, /* Perl (conflict with Prolog) */ | |||
107 | { "pm", "# " }, /* Perl module */ | |||
108 | { "ps", "% " }, /* postscript */ | |||
109 | { "psw", "% " }, /* postscript wrap */ | |||
110 | { "pswm", "% " }, /* postscript wrap */ | |||
111 | { "r", "# " }, /* ratfor */ | |||
112 | { "rc", " * " }, /* Microsoft Windows resource file */ | |||
113 | { "red", "% " }, /* psl/rlisp */ | |||
114 | { "sh", "# " }, /* shell */ | |||
115 | { "sl", "% " }, /* psl */ | |||
116 | { "spec", "-- " }, /* Ada */ | |||
117 | { "tex", "% " }, /* tex */ | |||
118 | { "y", " * " }, /* yacc */ | |||
119 | { "ye", " * " }, /* yacc-efl */ | |||
120 | { "yr", " * " }, /* yacc-ratfor */ | |||
121 | }; | |||
122 | ||||
123 | struct rcs_kw rcs_expkw[] = { | |||
124 | { "Author", RCS_KW_AUTHOR0x1000 }, | |||
125 | { "Date", RCS_KW_DATE0x2000 }, | |||
126 | { "Header", RCS_KW_HEADER((0x0100 | 0x0200 | 0x2000 | 0x1000 | 0x0800) | 0x0010) }, | |||
127 | { "Id", RCS_KW_ID(0x0100 | 0x0200 | 0x2000 | 0x1000 | 0x0800) }, | |||
128 | { "Locker", RCS_KW_LOCKER0x0040 }, | |||
129 | { "Log", RCS_KW_LOG0x4000 }, | |||
130 | { "Name", RCS_KW_NAME0x8000 }, | |||
131 | { "RCSfile", RCS_KW_RCSFILE0x0100 }, | |||
132 | { "Revision", RCS_KW_REVISION0x0200 }, | |||
133 | { "Source", RCS_KW_SOURCE0x0400 }, | |||
134 | { "State", RCS_KW_STATE0x0800 }, | |||
135 | { "Mdocdate", RCS_KW_MDOCDATE0x0020 }, | |||
136 | }; | |||
137 | ||||
138 | #define NB_COMTYPES(sizeof(rcs_comments)/sizeof(rcs_comments[0])) (sizeof(rcs_comments)/sizeof(rcs_comments[0])) | |||
139 | ||||
140 | static RCSNUM *rcs_get_revision(const char *, RCSFILE *); | |||
141 | int rcs_patch_lines(struct rcs_lines *, struct rcs_lines *, | |||
142 | struct rcs_line **, struct rcs_delta *); | |||
143 | static void rcs_freedelta(struct rcs_delta *); | |||
144 | static void rcs_strprint(const u_char *, size_t, FILE *); | |||
145 | ||||
146 | static void rcs_kwexp_line(char *, struct rcs_delta *, struct rcs_lines *, | |||
147 | struct rcs_line *, int mode); | |||
148 | ||||
149 | /* | |||
150 | * Prepare RCSFILE for parsing. The given file descriptor (if any) must be | |||
151 | * read-only and is closed on rcs_close(). | |||
152 | */ | |||
153 | RCSFILE * | |||
154 | rcs_open(const char *path, int fd, int flags, ...) | |||
155 | { | |||
156 | int mode; | |||
157 | mode_t fmode; | |||
158 | RCSFILE *rfp; | |||
159 | va_list vap; | |||
160 | struct stat st; | |||
161 | struct rcs_delta *rdp; | |||
162 | struct rcs_lock *lkr; | |||
163 | ||||
164 | fmode = S_IRUSR0000400|S_IRGRP0000040|S_IROTH0000004; | |||
165 | flags &= 0xffff; /* ditch any internal flags */ | |||
166 | ||||
167 | if (flags & RCS_CREATE(1<<2)) { | |||
168 | va_start(vap, flags)__builtin_va_start(vap, flags); | |||
169 | mode = va_arg(vap, int)__builtin_va_arg(vap, int); | |||
170 | va_end(vap)__builtin_va_end(vap); | |||
171 | fmode = (mode_t)mode; | |||
172 | } else { | |||
173 | if (fstat(fd, &st) == -1) | |||
174 | fatal("rcs_open: %s: fstat: %s", path, strerror(errno(*__errno()))); | |||
175 | fmode = st.st_mode; | |||
176 | } | |||
177 | ||||
178 | fmode &= ~cvs_umask; | |||
179 | ||||
180 | rfp = xcalloc(1, sizeof(*rfp)); | |||
181 | ||||
182 | rfp->rf_path = xstrdup(path); | |||
183 | rfp->rf_flags = flags | RCS_SLOCK(1<<6) | RCS_SYNCED(1<<5); | |||
184 | rfp->rf_mode = fmode; | |||
185 | if (fd == -1) | |||
186 | rfp->rf_file = NULL((void *)0); | |||
187 | else if ((rfp->rf_file = fdopen(fd, "r")) == NULL((void *)0)) | |||
188 | fatal("rcs_open: %s: fdopen: %s", path, strerror(errno(*__errno()))); | |||
189 | rfp->rf_dead = 0; | |||
190 | ||||
191 | TAILQ_INIT(&(rfp->rf_delta))do { (&(rfp->rf_delta))->tqh_first = ((void *)0); ( &(rfp->rf_delta))->tqh_last = &(&(rfp->rf_delta ))->tqh_first; } while (0); | |||
192 | TAILQ_INIT(&(rfp->rf_access))do { (&(rfp->rf_access))->tqh_first = ((void *)0); ( &(rfp->rf_access))->tqh_last = &(&(rfp-> rf_access))->tqh_first; } while (0); | |||
193 | TAILQ_INIT(&(rfp->rf_symbols))do { (&(rfp->rf_symbols))->tqh_first = ((void *)0); (&(rfp->rf_symbols))->tqh_last = &(&(rfp-> rf_symbols))->tqh_first; } while (0); | |||
194 | TAILQ_INIT(&(rfp->rf_locks))do { (&(rfp->rf_locks))->tqh_first = ((void *)0); ( &(rfp->rf_locks))->tqh_last = &(&(rfp->rf_locks ))->tqh_first; } while (0); | |||
195 | ||||
196 | if (!(rfp->rf_flags & RCS_CREATE(1<<2))) { | |||
197 | if (rcsparse_init(rfp)) | |||
198 | fatal("could not parse admin data"); | |||
199 | } | |||
200 | ||||
201 | /* fill in rd_locker */ | |||
202 | TAILQ_FOREACH(lkr, &(rfp->rf_locks), rl_list)for((lkr) = ((&(rfp->rf_locks))->tqh_first); (lkr) != ((void *)0); (lkr) = ((lkr)->rl_list.tqe_next)) { | |||
203 | if ((rdp = rcs_findrev(rfp, lkr->rl_num)) == NULL((void *)0)) { | |||
204 | rcs_close(rfp); | |||
205 | return (NULL((void *)0)); | |||
206 | } | |||
207 | ||||
208 | rdp->rd_locker = xstrdup(lkr->rl_name); | |||
209 | } | |||
210 | ||||
211 | return (rfp); | |||
212 | } | |||
213 | ||||
214 | /* | |||
215 | * rcs_close() | |||
216 | * | |||
217 | * Close an RCS file handle. | |||
218 | */ | |||
219 | void | |||
220 | rcs_close(RCSFILE *rfp) | |||
221 | { | |||
222 | struct rcs_delta *rdp; | |||
223 | struct rcs_access *rap; | |||
224 | struct rcs_lock *rlp; | |||
225 | struct rcs_sym *rsp; | |||
226 | ||||
227 | if ((rfp->rf_flags & RCS_WRITE(1<<1)) && !(rfp->rf_flags & RCS_SYNCED(1<<5))) | |||
228 | rcs_write(rfp); | |||
229 | ||||
230 | while (!TAILQ_EMPTY(&(rfp->rf_delta))(((&(rfp->rf_delta))->tqh_first) == ((void *)0))) { | |||
231 | rdp = TAILQ_FIRST(&(rfp->rf_delta))((&(rfp->rf_delta))->tqh_first); | |||
232 | TAILQ_REMOVE(&(rfp->rf_delta), rdp, rd_list)do { if (((rdp)->rd_list.tqe_next) != ((void *)0)) (rdp)-> rd_list.tqe_next->rd_list.tqe_prev = (rdp)->rd_list.tqe_prev ; else (&(rfp->rf_delta))->tqh_last = (rdp)->rd_list .tqe_prev; *(rdp)->rd_list.tqe_prev = (rdp)->rd_list.tqe_next ; ; ; } while (0); | |||
233 | rcs_freedelta(rdp); | |||
234 | } | |||
235 | ||||
236 | while (!TAILQ_EMPTY(&(rfp->rf_access))(((&(rfp->rf_access))->tqh_first) == ((void *)0))) { | |||
237 | rap = TAILQ_FIRST(&(rfp->rf_access))((&(rfp->rf_access))->tqh_first); | |||
238 | TAILQ_REMOVE(&(rfp->rf_access), rap, ra_list)do { if (((rap)->ra_list.tqe_next) != ((void *)0)) (rap)-> ra_list.tqe_next->ra_list.tqe_prev = (rap)->ra_list.tqe_prev ; else (&(rfp->rf_access))->tqh_last = (rap)->ra_list .tqe_prev; *(rap)->ra_list.tqe_prev = (rap)->ra_list.tqe_next ; ; ; } while (0); | |||
239 | free(rap->ra_name); | |||
240 | free(rap); | |||
241 | } | |||
242 | ||||
243 | while (!TAILQ_EMPTY(&(rfp->rf_symbols))(((&(rfp->rf_symbols))->tqh_first) == ((void *)0))) { | |||
244 | rsp = TAILQ_FIRST(&(rfp->rf_symbols))((&(rfp->rf_symbols))->tqh_first); | |||
245 | TAILQ_REMOVE(&(rfp->rf_symbols), rsp, rs_list)do { if (((rsp)->rs_list.tqe_next) != ((void *)0)) (rsp)-> rs_list.tqe_next->rs_list.tqe_prev = (rsp)->rs_list.tqe_prev ; else (&(rfp->rf_symbols))->tqh_last = (rsp)->rs_list .tqe_prev; *(rsp)->rs_list.tqe_prev = (rsp)->rs_list.tqe_next ; ; ; } while (0); | |||
246 | free(rsp->rs_num); | |||
247 | free(rsp->rs_name); | |||
248 | free(rsp); | |||
249 | } | |||
250 | ||||
251 | while (!TAILQ_EMPTY(&(rfp->rf_locks))(((&(rfp->rf_locks))->tqh_first) == ((void *)0))) { | |||
252 | rlp = TAILQ_FIRST(&(rfp->rf_locks))((&(rfp->rf_locks))->tqh_first); | |||
253 | TAILQ_REMOVE(&(rfp->rf_locks), rlp, rl_list)do { if (((rlp)->rl_list.tqe_next) != ((void *)0)) (rlp)-> rl_list.tqe_next->rl_list.tqe_prev = (rlp)->rl_list.tqe_prev ; else (&(rfp->rf_locks))->tqh_last = (rlp)->rl_list .tqe_prev; *(rlp)->rl_list.tqe_prev = (rlp)->rl_list.tqe_next ; ; ; } while (0); | |||
254 | free(rlp->rl_num); | |||
255 | free(rlp->rl_name); | |||
256 | free(rlp); | |||
257 | } | |||
258 | ||||
259 | free(rfp->rf_head); | |||
260 | free(rfp->rf_branch); | |||
261 | ||||
262 | if (rfp->rf_file != NULL((void *)0)) | |||
263 | fclose(rfp->rf_file); | |||
264 | free(rfp->rf_path); | |||
265 | free(rfp->rf_comment); | |||
266 | free(rfp->rf_expand); | |||
267 | free(rfp->rf_desc); | |||
268 | if (rfp->rf_pdata != NULL((void *)0)) | |||
269 | rcsparse_free(rfp); | |||
270 | free(rfp); | |||
271 | } | |||
272 | ||||
273 | /* | |||
274 | * rcs_write() | |||
275 | * | |||
276 | * Write the contents of the RCS file handle <rfp> to disk in the file whose | |||
277 | * path is in <rf_path>. | |||
278 | */ | |||
279 | void | |||
280 | rcs_write(RCSFILE *rfp) | |||
281 | { | |||
282 | FILE *fp; | |||
283 | char numbuf[CVS_REV_BUFSZ32], *fn, tmpdir[PATH_MAX1024]; | |||
284 | struct rcs_access *ap; | |||
285 | struct rcs_sym *symp; | |||
286 | struct rcs_branch *brp; | |||
287 | struct rcs_delta *rdp; | |||
288 | struct rcs_lock *lkp; | |||
289 | size_t len; | |||
290 | int fd, saved_errno; | |||
291 | ||||
292 | fd = -1; | |||
293 | ||||
294 | if (rfp->rf_flags & RCS_SYNCED(1<<5)) | |||
295 | return; | |||
296 | ||||
297 | if (cvs_noexec == 1) | |||
298 | return; | |||
299 | ||||
300 | /* Write operations need the whole file parsed */ | |||
301 | if (rcsparse_deltatexts(rfp, NULL((void *)0))) | |||
302 | fatal("rcs_write: rcsparse_deltatexts"); | |||
303 | ||||
304 | if (strlcpy(tmpdir, rfp->rf_path, sizeof(tmpdir)) >= sizeof(tmpdir)) | |||
305 | fatal("rcs_write: truncation"); | |||
306 | (void)xasprintf(&fn, "%s/rcs.XXXXXXXXXX", dirname(tmpdir)); | |||
307 | ||||
308 | if ((fd = mkstemp(fn)) == -1) | |||
309 | fatal("%s", fn); | |||
310 | ||||
311 | if ((fp = fdopen(fd, "w")) == NULL((void *)0)) { | |||
312 | saved_errno = errno(*__errno()); | |||
313 | (void)unlink(fn); | |||
314 | fatal("fdopen %s: %s", fn, strerror(saved_errno)); | |||
315 | } | |||
316 | ||||
317 | worklist_add(fn, &temp_files); | |||
318 | ||||
319 | if (rfp->rf_head != NULL((void *)0)) | |||
320 | rcsnum_tostr(rfp->rf_head, numbuf, sizeof(numbuf)); | |||
321 | else | |||
322 | numbuf[0] = '\0'; | |||
323 | ||||
324 | fprintf(fp, "head\t%s;\n", numbuf); | |||
325 | ||||
326 | if (rfp->rf_branch != NULL((void *)0)) { | |||
327 | rcsnum_tostr(rfp->rf_branch, numbuf, sizeof(numbuf)); | |||
328 | fprintf(fp, "branch\t%s;\n", numbuf); | |||
329 | } | |||
330 | ||||
331 | fputs("access", fp); | |||
332 | TAILQ_FOREACH(ap, &(rfp->rf_access), ra_list)for((ap) = ((&(rfp->rf_access))->tqh_first); (ap) != ((void *)0); (ap) = ((ap)->ra_list.tqe_next)) { | |||
333 | fprintf(fp, "\n\t%s", ap->ra_name); | |||
334 | } | |||
335 | fputs(";\n", fp); | |||
336 | ||||
337 | fprintf(fp, "symbols"); | |||
338 | TAILQ_FOREACH(symp, &(rfp->rf_symbols), rs_list)for((symp) = ((&(rfp->rf_symbols))->tqh_first); (symp ) != ((void *)0); (symp) = ((symp)->rs_list.tqe_next)) { | |||
339 | if (RCSNUM_ISBRANCH(symp->rs_num)((symp->rs_num)->rn_len % 2)) | |||
340 | rcsnum_addmagic(symp->rs_num); | |||
341 | rcsnum_tostr(symp->rs_num, numbuf, sizeof(numbuf)); | |||
342 | fprintf(fp, "\n\t%s:%s", symp->rs_name, numbuf); | |||
343 | } | |||
344 | fprintf(fp, ";\n"); | |||
345 | ||||
346 | fprintf(fp, "locks"); | |||
347 | TAILQ_FOREACH(lkp, &(rfp->rf_locks), rl_list)for((lkp) = ((&(rfp->rf_locks))->tqh_first); (lkp) != ((void *)0); (lkp) = ((lkp)->rl_list.tqe_next)) { | |||
348 | rcsnum_tostr(lkp->rl_num, numbuf, sizeof(numbuf)); | |||
349 | fprintf(fp, "\n\t%s:%s", lkp->rl_name, numbuf); | |||
350 | } | |||
351 | ||||
352 | fprintf(fp, ";"); | |||
353 | ||||
354 | if (rfp->rf_flags & RCS_SLOCK(1<<6)) | |||
355 | fprintf(fp, " strict;"); | |||
356 | fputc('\n', fp); | |||
357 | ||||
358 | fputs("comment\t@", fp); | |||
359 | if (rfp->rf_comment != NULL((void *)0)) { | |||
360 | rcs_strprint((const u_char *)rfp->rf_comment, | |||
361 | strlen(rfp->rf_comment), fp); | |||
362 | fputs("@;\n", fp); | |||
363 | } else | |||
364 | fputs("# @;\n", fp); | |||
365 | ||||
366 | if (rfp->rf_expand != NULL((void *)0)) { | |||
367 | fputs("expand @", fp); | |||
368 | rcs_strprint((const u_char *)rfp->rf_expand, | |||
369 | strlen(rfp->rf_expand), fp); | |||
370 | fputs("@;\n", fp); | |||
371 | } | |||
372 | ||||
373 | fputs("\n\n", fp); | |||
374 | ||||
375 | TAILQ_FOREACH(rdp, &(rfp->rf_delta), rd_list)for((rdp) = ((&(rfp->rf_delta))->tqh_first); (rdp) != ((void *)0); (rdp) = ((rdp)->rd_list.tqe_next)) { | |||
376 | fprintf(fp, "%s\n", rcsnum_tostr(rdp->rd_num, numbuf, | |||
377 | sizeof(numbuf))); | |||
378 | fprintf(fp, "date\t%d.%02d.%02d.%02d.%02d.%02d;", | |||
379 | rdp->rd_date.tm_year + 1900, rdp->rd_date.tm_mon + 1, | |||
380 | rdp->rd_date.tm_mday, rdp->rd_date.tm_hour, | |||
381 | rdp->rd_date.tm_min, rdp->rd_date.tm_sec); | |||
382 | fprintf(fp, "\tauthor %s;\tstate %s;\n", | |||
383 | rdp->rd_author, rdp->rd_state); | |||
384 | fputs("branches", fp); | |||
385 | TAILQ_FOREACH(brp, &(rdp->rd_branches), rb_list)for((brp) = ((&(rdp->rd_branches))->tqh_first); (brp ) != ((void *)0); (brp) = ((brp)->rb_list.tqe_next)) { | |||
386 | fprintf(fp, "\n\t%s", rcsnum_tostr(brp->rb_num, numbuf, | |||
387 | sizeof(numbuf))); | |||
388 | } | |||
389 | fputs(";\n", fp); | |||
390 | fprintf(fp, "next\t%s;\n\n", rcsnum_tostr(rdp->rd_next, | |||
391 | numbuf, sizeof(numbuf))); | |||
392 | } | |||
393 | ||||
394 | fputs("\ndesc\n@", fp); | |||
395 | if (rfp->rf_desc != NULL((void *)0) && (len = strlen(rfp->rf_desc)) > 0) { | |||
396 | rcs_strprint((const u_char *)rfp->rf_desc, len, fp); | |||
397 | if (rfp->rf_desc[len-1] != '\n') | |||
398 | fputc('\n', fp); | |||
399 | } | |||
400 | fputs("@\n", fp); | |||
401 | ||||
402 | /* deltatexts */ | |||
403 | TAILQ_FOREACH(rdp, &(rfp->rf_delta), rd_list)for((rdp) = ((&(rfp->rf_delta))->tqh_first); (rdp) != ((void *)0); (rdp) = ((rdp)->rd_list.tqe_next)) { | |||
404 | fprintf(fp, "\n\n%s\n", rcsnum_tostr(rdp->rd_num, numbuf, | |||
405 | sizeof(numbuf))); | |||
406 | fputs("log\n@", fp); | |||
407 | if (rdp->rd_log != NULL((void *)0)) { | |||
408 | len = strlen(rdp->rd_log); | |||
409 | rcs_strprint((const u_char *)rdp->rd_log, len, fp); | |||
410 | if (len == 0 || rdp->rd_log[len-1] != '\n') | |||
411 | fputc('\n', fp); | |||
412 | } | |||
413 | fputs("@\ntext\n@", fp); | |||
414 | if (rdp->rd_text != NULL((void *)0)) | |||
415 | rcs_strprint(rdp->rd_text, rdp->rd_tlen, fp); | |||
416 | fputs("@\n", fp); | |||
417 | } | |||
418 | ||||
419 | if (fchmod(fd, rfp->rf_mode) == -1) { | |||
420 | saved_errno = errno(*__errno()); | |||
421 | (void)unlink(fn); | |||
422 | fatal("fchmod %s: %s", fn, strerror(saved_errno)); | |||
423 | } | |||
424 | ||||
425 | (void)fclose(fp); | |||
426 | ||||
427 | if (rename(fn, rfp->rf_path) == -1) { | |||
428 | saved_errno = errno(*__errno()); | |||
429 | (void)unlink(fn); | |||
430 | fatal("rename(%s, %s): %s", fn, rfp->rf_path, | |||
431 | strerror(saved_errno)); | |||
432 | } | |||
433 | ||||
434 | rfp->rf_flags |= RCS_SYNCED(1<<5); | |||
435 | free(fn); | |||
436 | } | |||
437 | ||||
438 | /* | |||
439 | * rcs_head_get() | |||
440 | * | |||
441 | * Retrieve the revision number of the head revision for the RCS file <file>. | |||
442 | */ | |||
443 | RCSNUM * | |||
444 | rcs_head_get(RCSFILE *file) | |||
445 | { | |||
446 | struct rcs_branch *brp; | |||
447 | struct rcs_delta *rdp; | |||
448 | RCSNUM *rev, *rootrev; | |||
449 | ||||
450 | if (file->rf_head == NULL((void *)0)) | |||
451 | return NULL((void *)0); | |||
452 | ||||
453 | rev = rcsnum_alloc(); | |||
454 | if (file->rf_branch != NULL((void *)0)) { | |||
455 | /* we have a default branch, use that to calculate the | |||
456 | * real HEAD*/ | |||
457 | rootrev = rcsnum_alloc(); | |||
458 | rcsnum_cpy(file->rf_branch, rootrev, | |||
459 | file->rf_branch->rn_len - 1); | |||
460 | if ((rdp = rcs_findrev(file, rootrev)) == NULL((void *)0)) | |||
461 | fatal("rcs_head_get: could not find root revision"); | |||
462 | ||||
463 | /* HEAD should be the last revision on the default branch */ | |||
464 | TAILQ_FOREACH(brp, &(rdp->rd_branches), rb_list)for((brp) = ((&(rdp->rd_branches))->tqh_first); (brp ) != ((void *)0); (brp) = ((brp)->rb_list.tqe_next)) { | |||
465 | if (rcsnum_cmp(brp->rb_num, file->rf_branch, | |||
466 | file->rf_branch->rn_len) == 0) | |||
467 | break; | |||
468 | } | |||
469 | free(rootrev); | |||
470 | ||||
471 | if (brp == NULL((void *)0)) | |||
472 | fatal("rcs_head_get: could not find first default " | |||
473 | "branch revision"); | |||
474 | ||||
475 | if ((rdp = rcs_findrev(file, brp->rb_num)) == NULL((void *)0)) | |||
476 | fatal("rcs_head_get: could not find branch revision"); | |||
477 | while (rdp->rd_next->rn_len != 0) | |||
478 | if ((rdp = rcs_findrev(file, rdp->rd_next)) == NULL((void *)0)) | |||
479 | fatal("rcs_head_get: could not find " | |||
480 | "next branch revision"); | |||
481 | ||||
482 | rcsnum_cpy(rdp->rd_num, rev, 0); | |||
483 | } else { | |||
484 | rcsnum_cpy(file->rf_head, rev, 0); | |||
485 | } | |||
486 | ||||
487 | return (rev); | |||
488 | } | |||
489 | ||||
490 | /* | |||
491 | * rcs_head_set() | |||
492 | * | |||
493 | * Set the revision number of the head revision for the RCS file <file> to | |||
494 | * <rev>, which must reference a valid revision within the file. | |||
495 | */ | |||
496 | int | |||
497 | rcs_head_set(RCSFILE *file, RCSNUM *rev) | |||
498 | { | |||
499 | if (rcs_findrev(file, rev) == NULL((void *)0)) | |||
500 | return (-1); | |||
501 | ||||
502 | if (file->rf_head == NULL((void *)0)) | |||
503 | file->rf_head = rcsnum_alloc(); | |||
504 | ||||
505 | rcsnum_cpy(rev, file->rf_head, 0); | |||
506 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
507 | return (0); | |||
508 | } | |||
509 | ||||
510 | /* | |||
511 | * rcs_branch_new() | |||
512 | * | |||
513 | * Create a new branch out of supplied revision for the RCS file <file>. | |||
514 | */ | |||
515 | RCSNUM * | |||
516 | rcs_branch_new(RCSFILE *file, RCSNUM *rev) | |||
517 | { | |||
518 | RCSNUM *brev; | |||
519 | struct rcs_sym *sym; | |||
520 | ||||
521 | if ((brev = rcsnum_new_branch(rev)) == NULL((void *)0)) | |||
522 | return (NULL((void *)0)); | |||
523 | ||||
524 | for (;;) { | |||
525 | TAILQ_FOREACH(sym, &(file->rf_symbols), rs_list)for((sym) = ((&(file->rf_symbols))->tqh_first); (sym ) != ((void *)0); (sym) = ((sym)->rs_list.tqe_next)) | |||
526 | if (!rcsnum_cmp(sym->rs_num, brev, 0)) | |||
527 | break; | |||
528 | ||||
529 | if (sym == NULL((void *)0)) | |||
530 | break; | |||
531 | ||||
532 | if (rcsnum_inc(brev) == NULL((void *)0) || | |||
533 | rcsnum_inc(brev) == NULL((void *)0)) { | |||
534 | free(brev); | |||
535 | return (NULL((void *)0)); | |||
536 | } | |||
537 | } | |||
538 | ||||
539 | return (brev); | |||
540 | } | |||
541 | ||||
542 | /* | |||
543 | * rcs_branch_get() | |||
544 | * | |||
545 | * Retrieve the default branch number for the RCS file <file>. | |||
546 | * Returns the number on success. If NULL is returned, then there is no | |||
547 | * default branch for this file. | |||
548 | */ | |||
549 | const RCSNUM * | |||
550 | rcs_branch_get(RCSFILE *file) | |||
551 | { | |||
552 | return (file->rf_branch); | |||
553 | } | |||
554 | ||||
555 | /* | |||
556 | * rcs_branch_set() | |||
557 | * | |||
558 | * Set the default branch for the RCS file <file> to <bnum>. | |||
559 | * Returns 0 on success, -1 on failure. | |||
560 | */ | |||
561 | int | |||
562 | rcs_branch_set(RCSFILE *file, const RCSNUM *bnum) | |||
563 | { | |||
564 | if (file->rf_branch == NULL((void *)0)) | |||
565 | file->rf_branch = rcsnum_alloc(); | |||
566 | ||||
567 | rcsnum_cpy(bnum, file->rf_branch, 0); | |||
568 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
569 | return (0); | |||
570 | } | |||
571 | ||||
572 | /* | |||
573 | * rcs_access_add() | |||
574 | * | |||
575 | * Add the login name <login> to the access list for the RCS file <file>. | |||
576 | * Returns 0 on success, or -1 on failure. | |||
577 | */ | |||
578 | int | |||
579 | rcs_access_add(RCSFILE *file, const char *login) | |||
580 | { | |||
581 | struct rcs_access *ap; | |||
582 | ||||
583 | /* first look for duplication */ | |||
584 | TAILQ_FOREACH(ap, &(file->rf_access), ra_list)for((ap) = ((&(file->rf_access))->tqh_first); (ap) != ((void *)0); (ap) = ((ap)->ra_list.tqe_next)) { | |||
585 | if (strcmp(ap->ra_name, login) == 0) | |||
586 | return (-1); | |||
587 | } | |||
588 | ||||
589 | ap = xmalloc(sizeof(*ap)); | |||
590 | ap->ra_name = xstrdup(login); | |||
591 | TAILQ_INSERT_TAIL(&(file->rf_access), ap, ra_list)do { (ap)->ra_list.tqe_next = ((void *)0); (ap)->ra_list .tqe_prev = (&(file->rf_access))->tqh_last; *(& (file->rf_access))->tqh_last = (ap); (&(file->rf_access ))->tqh_last = &(ap)->ra_list.tqe_next; } while (0); | |||
592 | ||||
593 | /* not synced anymore */ | |||
594 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
595 | return (0); | |||
596 | } | |||
597 | ||||
598 | /* | |||
599 | * rcs_access_remove() | |||
600 | * | |||
601 | * Remove an entry with login name <login> from the access list of the RCS | |||
602 | * file <file>. | |||
603 | * Returns 0 on success, or -1 on failure. | |||
604 | */ | |||
605 | int | |||
606 | rcs_access_remove(RCSFILE *file, const char *login) | |||
607 | { | |||
608 | struct rcs_access *ap; | |||
609 | ||||
610 | TAILQ_FOREACH(ap, &(file->rf_access), ra_list)for((ap) = ((&(file->rf_access))->tqh_first); (ap) != ((void *)0); (ap) = ((ap)->ra_list.tqe_next)) | |||
611 | if (strcmp(ap->ra_name, login) == 0) | |||
612 | break; | |||
613 | ||||
614 | if (ap == NULL((void *)0)) | |||
615 | return (-1); | |||
616 | ||||
617 | TAILQ_REMOVE(&(file->rf_access), ap, ra_list)do { if (((ap)->ra_list.tqe_next) != ((void *)0)) (ap)-> ra_list.tqe_next->ra_list.tqe_prev = (ap)->ra_list.tqe_prev ; else (&(file->rf_access))->tqh_last = (ap)->ra_list .tqe_prev; *(ap)->ra_list.tqe_prev = (ap)->ra_list.tqe_next ; ; ; } while (0); | |||
618 | free(ap->ra_name); | |||
619 | free(ap); | |||
620 | ||||
621 | /* not synced anymore */ | |||
622 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
623 | return (0); | |||
624 | } | |||
625 | ||||
626 | /* | |||
627 | * rcs_sym_add() | |||
628 | * | |||
629 | * Add a symbol to the list of symbols for the RCS file <rfp>. The new symbol | |||
630 | * is named <sym> and is bound to the RCS revision <snum>. | |||
631 | */ | |||
632 | int | |||
633 | rcs_sym_add(RCSFILE *rfp, const char *sym, RCSNUM *snum) | |||
634 | { | |||
635 | struct rcs_sym *symp; | |||
636 | ||||
637 | if (!rcs_sym_check(sym)) | |||
638 | return (-1); | |||
639 | ||||
640 | /* first look for duplication */ | |||
641 | TAILQ_FOREACH(symp, &(rfp->rf_symbols), rs_list)for((symp) = ((&(rfp->rf_symbols))->tqh_first); (symp ) != ((void *)0); (symp) = ((symp)->rs_list.tqe_next)) { | |||
642 | if (strcmp(symp->rs_name, sym) == 0) | |||
643 | return (1); | |||
644 | } | |||
645 | ||||
646 | symp = xmalloc(sizeof(*symp)); | |||
647 | symp->rs_name = xstrdup(sym); | |||
648 | symp->rs_num = rcsnum_alloc(); | |||
649 | rcsnum_cpy(snum, symp->rs_num, 0); | |||
650 | ||||
651 | TAILQ_INSERT_HEAD(&(rfp->rf_symbols), symp, rs_list)do { if (((symp)->rs_list.tqe_next = (&(rfp->rf_symbols ))->tqh_first) != ((void *)0)) (&(rfp->rf_symbols)) ->tqh_first->rs_list.tqe_prev = &(symp)->rs_list .tqe_next; else (&(rfp->rf_symbols))->tqh_last = & (symp)->rs_list.tqe_next; (&(rfp->rf_symbols))-> tqh_first = (symp); (symp)->rs_list.tqe_prev = &(& (rfp->rf_symbols))->tqh_first; } while (0); | |||
652 | ||||
653 | /* not synced anymore */ | |||
654 | rfp->rf_flags &= ~RCS_SYNCED(1<<5); | |||
655 | return (0); | |||
656 | } | |||
657 | ||||
658 | /* | |||
659 | * rcs_sym_remove() | |||
660 | * | |||
661 | * Remove the symbol with name <sym> from the symbol list for the RCS file | |||
662 | * <file>. If no such symbol is found, the call fails and returns with an | |||
663 | * error. | |||
664 | * Returns 0 on success, or -1 on failure. | |||
665 | */ | |||
666 | int | |||
667 | rcs_sym_remove(RCSFILE *file, const char *sym) | |||
668 | { | |||
669 | struct rcs_sym *symp; | |||
670 | ||||
671 | if (!rcs_sym_check(sym)) | |||
672 | return (-1); | |||
673 | ||||
674 | TAILQ_FOREACH(symp, &(file->rf_symbols), rs_list)for((symp) = ((&(file->rf_symbols))->tqh_first); (symp ) != ((void *)0); (symp) = ((symp)->rs_list.tqe_next)) | |||
675 | if (strcmp(symp->rs_name, sym) == 0) | |||
676 | break; | |||
677 | ||||
678 | if (symp == NULL((void *)0)) | |||
679 | return (-1); | |||
680 | ||||
681 | TAILQ_REMOVE(&(file->rf_symbols), symp, rs_list)do { if (((symp)->rs_list.tqe_next) != ((void *)0)) (symp) ->rs_list.tqe_next->rs_list.tqe_prev = (symp)->rs_list .tqe_prev; else (&(file->rf_symbols))->tqh_last = ( symp)->rs_list.tqe_prev; *(symp)->rs_list.tqe_prev = (symp )->rs_list.tqe_next; ; ; } while (0); | |||
682 | free(symp->rs_name); | |||
683 | free(symp->rs_num); | |||
684 | free(symp); | |||
685 | ||||
686 | /* not synced anymore */ | |||
687 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
688 | return (0); | |||
689 | } | |||
690 | ||||
691 | /* | |||
692 | * rcs_sym_get() | |||
693 | * | |||
694 | * Find a specific symbol <sym> entry in the tree of the RCS file <file>. | |||
695 | * | |||
696 | * Returns a pointer to the symbol on success, or NULL on failure. | |||
697 | */ | |||
698 | struct rcs_sym * | |||
699 | rcs_sym_get(RCSFILE *file, const char *sym) | |||
700 | { | |||
701 | struct rcs_sym *symp; | |||
702 | ||||
703 | TAILQ_FOREACH(symp, &(file->rf_symbols), rs_list)for((symp) = ((&(file->rf_symbols))->tqh_first); (symp ) != ((void *)0); (symp) = ((symp)->rs_list.tqe_next)) | |||
704 | if (strcmp(symp->rs_name, sym) == 0) | |||
705 | return (symp); | |||
706 | ||||
707 | return (NULL((void *)0)); | |||
708 | } | |||
709 | ||||
710 | /* | |||
711 | * rcs_sym_getrev() | |||
712 | * | |||
713 | * Retrieve the RCS revision number associated with the symbol <sym> for the | |||
714 | * RCS file <file>. The returned value is a dynamically-allocated copy and | |||
715 | * should be freed by the caller once they are done with it. | |||
716 | * Returns the RCSNUM on success, or NULL on failure. | |||
717 | */ | |||
718 | RCSNUM * | |||
719 | rcs_sym_getrev(RCSFILE *file, const char *sym) | |||
720 | { | |||
721 | RCSNUM *num; | |||
722 | struct rcs_sym *symp; | |||
723 | ||||
724 | if (!rcs_sym_check(sym) || file->rf_head == NULL((void *)0)) | |||
725 | return (NULL((void *)0)); | |||
726 | ||||
727 | if (!strcmp(sym, RCS_HEAD_BRANCH"HEAD")) { | |||
728 | num = rcsnum_alloc(); | |||
729 | rcsnum_cpy(file->rf_head, num, 0); | |||
730 | return (num); | |||
731 | } | |||
732 | ||||
733 | num = NULL((void *)0); | |||
734 | TAILQ_FOREACH(symp, &(file->rf_symbols), rs_list)for((symp) = ((&(file->rf_symbols))->tqh_first); (symp ) != ((void *)0); (symp) = ((symp)->rs_list.tqe_next)) | |||
735 | if (strcmp(symp->rs_name, sym) == 0) | |||
736 | break; | |||
737 | ||||
738 | if (symp != NULL((void *)0)) { | |||
739 | num = rcsnum_alloc(); | |||
740 | rcsnum_cpy(symp->rs_num, num, 0); | |||
741 | } | |||
742 | ||||
743 | return (num); | |||
744 | } | |||
745 | ||||
746 | /* | |||
747 | * rcs_sym_check() | |||
748 | * | |||
749 | * Check the RCS symbol name <sym> for any unsupported characters. | |||
750 | * Returns 1 if the tag is correct, 0 if it isn't valid. | |||
751 | */ | |||
752 | int | |||
753 | rcs_sym_check(const char *sym) | |||
754 | { | |||
755 | int ret; | |||
756 | const unsigned char *cp; | |||
757 | ||||
758 | ret = 1; | |||
759 | cp = sym; | |||
760 | if (!isalpha(*cp++)) | |||
761 | return (0); | |||
762 | ||||
763 | for (; *cp != '\0'; cp++) | |||
764 | if (!isgraph(*cp) || (strchr(rcs_sym_invch, *cp) != NULL((void *)0))) { | |||
765 | ret = 0; | |||
766 | break; | |||
767 | } | |||
768 | ||||
769 | return (ret); | |||
770 | } | |||
771 | ||||
772 | /* | |||
773 | * rcs_lock_getmode() | |||
774 | * | |||
775 | * Retrieve the locking mode of the RCS file <file>. | |||
776 | */ | |||
777 | int | |||
778 | rcs_lock_getmode(RCSFILE *file) | |||
779 | { | |||
780 | return (file->rf_flags & RCS_SLOCK(1<<6)) ? RCS_LOCK_STRICT1 : RCS_LOCK_LOOSE0; | |||
781 | } | |||
782 | ||||
783 | /* | |||
784 | * rcs_lock_setmode() | |||
785 | * | |||
786 | * Set the locking mode of the RCS file <file> to <mode>, which must either | |||
787 | * be RCS_LOCK_LOOSE or RCS_LOCK_STRICT. | |||
788 | * Returns the previous mode on success, or -1 on failure. | |||
789 | */ | |||
790 | int | |||
791 | rcs_lock_setmode(RCSFILE *file, int mode) | |||
792 | { | |||
793 | int pmode; | |||
794 | pmode = rcs_lock_getmode(file); | |||
795 | ||||
796 | if (mode == RCS_LOCK_STRICT1) | |||
797 | file->rf_flags |= RCS_SLOCK(1<<6); | |||
798 | else if (mode == RCS_LOCK_LOOSE0) | |||
799 | file->rf_flags &= ~RCS_SLOCK(1<<6); | |||
800 | else | |||
801 | fatal("rcs_lock_setmode: invalid mode `%d'", mode); | |||
802 | ||||
803 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
804 | return (pmode); | |||
805 | } | |||
806 | ||||
807 | /* | |||
808 | * rcs_lock_add() | |||
809 | * | |||
810 | * Add an RCS lock for the user <user> on revision <rev>. | |||
811 | * Returns 0 on success, or -1 on failure. | |||
812 | */ | |||
813 | int | |||
814 | rcs_lock_add(RCSFILE *file, const char *user, RCSNUM *rev) | |||
815 | { | |||
816 | struct rcs_lock *lkp; | |||
817 | ||||
818 | /* first look for duplication */ | |||
819 | TAILQ_FOREACH(lkp, &(file->rf_locks), rl_list)for((lkp) = ((&(file->rf_locks))->tqh_first); (lkp) != ((void *)0); (lkp) = ((lkp)->rl_list.tqe_next)) { | |||
820 | if (strcmp(lkp->rl_name, user) == 0 && | |||
821 | rcsnum_cmp(rev, lkp->rl_num, 0) == 0) | |||
822 | return (-1); | |||
823 | } | |||
824 | ||||
825 | lkp = xmalloc(sizeof(*lkp)); | |||
826 | lkp->rl_name = xstrdup(user); | |||
827 | lkp->rl_num = rcsnum_alloc(); | |||
828 | rcsnum_cpy(rev, lkp->rl_num, 0); | |||
829 | ||||
830 | TAILQ_INSERT_TAIL(&(file->rf_locks), lkp, rl_list)do { (lkp)->rl_list.tqe_next = ((void *)0); (lkp)->rl_list .tqe_prev = (&(file->rf_locks))->tqh_last; *(&( file->rf_locks))->tqh_last = (lkp); (&(file->rf_locks ))->tqh_last = &(lkp)->rl_list.tqe_next; } while (0 ); | |||
831 | ||||
832 | /* not synced anymore */ | |||
833 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
834 | return (0); | |||
835 | } | |||
836 | ||||
837 | ||||
838 | /* | |||
839 | * rcs_lock_remove() | |||
840 | * | |||
841 | * Remove the RCS lock on revision <rev>. | |||
842 | * Returns 0 on success, or -1 on failure. | |||
843 | */ | |||
844 | int | |||
845 | rcs_lock_remove(RCSFILE *file, const char *user, RCSNUM *rev) | |||
846 | { | |||
847 | struct rcs_lock *lkp; | |||
848 | ||||
849 | TAILQ_FOREACH(lkp, &(file->rf_locks), rl_list)for((lkp) = ((&(file->rf_locks))->tqh_first); (lkp) != ((void *)0); (lkp) = ((lkp)->rl_list.tqe_next)) { | |||
850 | if (strcmp(lkp->rl_name, user) == 0 && | |||
851 | rcsnum_cmp(lkp->rl_num, rev, 0) == 0) | |||
852 | break; | |||
853 | } | |||
854 | ||||
855 | if (lkp == NULL((void *)0)) | |||
856 | return (-1); | |||
857 | ||||
858 | TAILQ_REMOVE(&(file->rf_locks), lkp, rl_list)do { if (((lkp)->rl_list.tqe_next) != ((void *)0)) (lkp)-> rl_list.tqe_next->rl_list.tqe_prev = (lkp)->rl_list.tqe_prev ; else (&(file->rf_locks))->tqh_last = (lkp)->rl_list .tqe_prev; *(lkp)->rl_list.tqe_prev = (lkp)->rl_list.tqe_next ; ; ; } while (0); | |||
859 | free(lkp->rl_num); | |||
860 | free(lkp->rl_name); | |||
861 | free(lkp); | |||
862 | ||||
863 | /* not synced anymore */ | |||
864 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
865 | return (0); | |||
866 | } | |||
867 | ||||
868 | /* | |||
869 | * rcs_desc_get() | |||
870 | * | |||
871 | * Retrieve the description for the RCS file <file>. | |||
872 | */ | |||
873 | const char * | |||
874 | rcs_desc_get(RCSFILE *file) | |||
875 | { | |||
876 | return (file->rf_desc); | |||
877 | } | |||
878 | ||||
879 | /* | |||
880 | * rcs_desc_set() | |||
881 | * | |||
882 | * Set the description for the RCS file <file>. | |||
883 | */ | |||
884 | void | |||
885 | rcs_desc_set(RCSFILE *file, const char *desc) | |||
886 | { | |||
887 | char *tmp; | |||
888 | ||||
889 | tmp = xstrdup(desc); | |||
890 | free(file->rf_desc); | |||
891 | file->rf_desc = tmp; | |||
892 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
893 | } | |||
894 | ||||
895 | /* | |||
896 | * rcs_comment_lookup() | |||
897 | * | |||
898 | * Lookup the assumed comment leader based on a file's suffix. | |||
899 | * Returns a pointer to the string on success, or NULL on failure. | |||
900 | */ | |||
901 | const char * | |||
902 | rcs_comment_lookup(const char *filename) | |||
903 | { | |||
904 | int i; | |||
905 | const char *sp; | |||
906 | ||||
907 | if ((sp = strrchr(filename, '.')) == NULL((void *)0)) | |||
908 | return (NULL((void *)0)); | |||
909 | sp++; | |||
910 | ||||
911 | for (i = 0; i < (int)NB_COMTYPES(sizeof(rcs_comments)/sizeof(rcs_comments[0])); i++) | |||
912 | if (strcmp(rcs_comments[i].rc_suffix, sp) == 0) | |||
913 | return (rcs_comments[i].rc_cstr); | |||
914 | return (NULL((void *)0)); | |||
915 | } | |||
916 | ||||
917 | /* | |||
918 | * rcs_comment_get() | |||
919 | * | |||
920 | * Retrieve the comment leader for the RCS file <file>. | |||
921 | */ | |||
922 | const char * | |||
923 | rcs_comment_get(RCSFILE *file) | |||
924 | { | |||
925 | return (file->rf_comment); | |||
926 | } | |||
927 | ||||
928 | /* | |||
929 | * rcs_comment_set() | |||
930 | * | |||
931 | * Set the comment leader for the RCS file <file>. | |||
932 | */ | |||
933 | void | |||
934 | rcs_comment_set(RCSFILE *file, const char *comment) | |||
935 | { | |||
936 | char *tmp; | |||
937 | ||||
938 | tmp = xstrdup(comment); | |||
939 | free(file->rf_comment); | |||
940 | file->rf_comment = tmp; | |||
941 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
942 | } | |||
943 | ||||
944 | int | |||
945 | rcs_patch_lines(struct rcs_lines *dlines, struct rcs_lines *plines, | |||
946 | struct rcs_line **alines, struct rcs_delta *rdp) | |||
947 | { | |||
948 | u_char op; | |||
949 | char *ep; | |||
950 | struct rcs_line *lp, *dlp, *ndlp; | |||
951 | int i, lineno, nbln; | |||
952 | u_char tmp; | |||
953 | ||||
954 | dlp = TAILQ_FIRST(&(dlines->l_lines))((&(dlines->l_lines))->tqh_first); | |||
955 | lp = TAILQ_FIRST(&(plines->l_lines))((&(plines->l_lines))->tqh_first); | |||
956 | ||||
957 | /* skip first bogus line */ | |||
958 | for (lp = TAILQ_NEXT(lp, l_list)((lp)->l_list.tqe_next); lp != NULL((void *)0); | |||
959 | lp = TAILQ_NEXT(lp, l_list)((lp)->l_list.tqe_next)) { | |||
960 | if (lp->l_len < 2) | |||
961 | fatal("line too short, RCS patch seems broken"); | |||
962 | op = *(lp->l_line); | |||
963 | /* NUL-terminate line buffer for strtol() safety. */ | |||
964 | tmp = lp->l_line[lp->l_len - 1]; | |||
965 | lp->l_line[lp->l_len - 1] = '\0'; | |||
966 | lineno = (int)strtol((char*)(lp->l_line + 1), &ep, 10); | |||
967 | if (lineno - 1 > dlines->l_nblines || lineno < 0) { | |||
968 | fatal("invalid line specification in RCS patch"); | |||
969 | } | |||
970 | ep++; | |||
971 | nbln = (int)strtol(ep, &ep, 10); | |||
972 | /* Restore the last byte of the buffer */ | |||
973 | lp->l_line[lp->l_len - 1] = tmp; | |||
974 | if (nbln < 0) | |||
975 | fatal("invalid line number specification in RCS patch"); | |||
976 | ||||
977 | /* find the appropriate line */ | |||
978 | for (;;) { | |||
979 | if (dlp == NULL((void *)0)) | |||
980 | break; | |||
981 | if (dlp->l_lineno == lineno) | |||
982 | break; | |||
983 | if (dlp->l_lineno > lineno) { | |||
984 | dlp = TAILQ_PREV(dlp, tqh, l_list)(*(((struct tqh *)((dlp)->l_list.tqe_prev))->tqh_last)); | |||
985 | } else if (dlp->l_lineno < lineno) { | |||
986 | if (((ndlp = TAILQ_NEXT(dlp, l_list)((dlp)->l_list.tqe_next)) == NULL((void *)0)) || | |||
987 | ndlp->l_lineno > lineno) | |||
988 | break; | |||
989 | dlp = ndlp; | |||
990 | } | |||
991 | } | |||
992 | if (dlp
| |||
993 | fatal("can't find referenced line in RCS patch"); | |||
994 | ||||
995 | if (op == 'd') { | |||
996 | for (i = 0; (i < nbln) && (dlp
| |||
997 | ndlp = TAILQ_NEXT(dlp, l_list)((dlp)->l_list.tqe_next); | |||
998 | TAILQ_REMOVE(&(dlines->l_lines), dlp, l_list)do { if (((dlp)->l_list.tqe_next) != ((void *)0)) (dlp)-> l_list.tqe_next->l_list.tqe_prev = (dlp)->l_list.tqe_prev ; else (&(dlines->l_lines))->tqh_last = (dlp)->l_list .tqe_prev; *(dlp)->l_list.tqe_prev = (dlp)->l_list.tqe_next ; ; ; } while (0); | |||
999 | if (alines
| |||
1000 | dlp->l_delta = rdp; | |||
1001 | alines[dlp->l_lineno_orig - 1] = | |||
1002 | dlp; | |||
1003 | } else | |||
1004 | free(dlp); | |||
1005 | dlp = ndlp; | |||
1006 | /* last line is gone - reset dlp */ | |||
1007 | if (dlp
| |||
1008 | ndlp = TAILQ_LAST(&(dlines->l_lines),(*(((struct tqh *)((&(dlines->l_lines))->tqh_last)) ->tqh_last)) | |||
1009 | tqh)(*(((struct tqh *)((&(dlines->l_lines))->tqh_last)) ->tqh_last)); | |||
1010 | dlp = ndlp; | |||
1011 | } | |||
1012 | } | |||
1013 | } else if (op == 'a') { | |||
1014 | for (i = 0; i < nbln; i++) { | |||
1015 | ndlp = lp; | |||
1016 | lp = TAILQ_NEXT(lp, l_list)((lp)->l_list.tqe_next); | |||
1017 | if (lp == NULL((void *)0)) | |||
1018 | fatal("truncated RCS patch"); | |||
1019 | TAILQ_REMOVE(&(plines->l_lines), lp, l_list)do { if (((lp)->l_list.tqe_next) != ((void *)0)) (lp)-> l_list.tqe_next->l_list.tqe_prev = (lp)->l_list.tqe_prev ; else (&(plines->l_lines))->tqh_last = (lp)->l_list .tqe_prev; *(lp)->l_list.tqe_prev = (lp)->l_list.tqe_next ; ; ; } while (0); | |||
1020 | if (alines != NULL((void *)0)) { | |||
1021 | if (lp->l_needsfree == 1) | |||
1022 | free(lp->l_line); | |||
1023 | lp->l_line = NULL((void *)0); | |||
1024 | lp->l_needsfree = 0; | |||
1025 | } | |||
1026 | lp->l_delta = rdp; | |||
1027 | TAILQ_INSERT_AFTER(&(dlines->l_lines), dlp,do { if (((lp)->l_list.tqe_next = (dlp)->l_list.tqe_next ) != ((void *)0)) (lp)->l_list.tqe_next->l_list.tqe_prev = &(lp)->l_list.tqe_next; else (&(dlines->l_lines ))->tqh_last = &(lp)->l_list.tqe_next; (dlp)->l_list .tqe_next = (lp); (lp)->l_list.tqe_prev = &(dlp)->l_list .tqe_next; } while (0) | |||
1028 | lp, l_list)do { if (((lp)->l_list.tqe_next = (dlp)->l_list.tqe_next ) != ((void *)0)) (lp)->l_list.tqe_next->l_list.tqe_prev = &(lp)->l_list.tqe_next; else (&(dlines->l_lines ))->tqh_last = &(lp)->l_list.tqe_next; (dlp)->l_list .tqe_next = (lp); (lp)->l_list.tqe_prev = &(dlp)->l_list .tqe_next; } while (0); | |||
1029 | dlp = lp; | |||
1030 | ||||
1031 | /* we don't want lookup to block on those */ | |||
1032 | lp->l_lineno = lineno; | |||
1033 | ||||
1034 | lp = ndlp; | |||
1035 | } | |||
1036 | } else | |||
1037 | fatal("unknown RCS patch operation `%c'", op); | |||
1038 | ||||
1039 | /* last line of the patch, done */ | |||
1040 | if (lp->l_lineno == plines->l_nblines) | |||
1041 | break; | |||
1042 | } | |||
1043 | ||||
1044 | /* once we're done patching, rebuild the line numbers */ | |||
1045 | lineno = 0; | |||
1046 | TAILQ_FOREACH(lp, &(dlines->l_lines), l_list)for((lp) = ((&(dlines->l_lines))->tqh_first); (lp) != ((void *)0); (lp) = ((lp)->l_list.tqe_next)) | |||
1047 | lp->l_lineno = lineno++; | |||
| ||||
1048 | dlines->l_nblines = lineno - 1; | |||
1049 | ||||
1050 | return (0); | |||
1051 | } | |||
1052 | ||||
1053 | void | |||
1054 | rcs_delta_stats(struct rcs_delta *rdp, int *ladded, int *lremoved) | |||
1055 | { | |||
1056 | struct rcs_lines *plines; | |||
1057 | struct rcs_line *lp; | |||
1058 | int added, i, nbln, removed; | |||
1059 | char op, *ep; | |||
1060 | u_char tmp; | |||
1061 | ||||
1062 | added = removed = 0; | |||
1063 | ||||
1064 | plines = cvs_splitlines(rdp->rd_text, rdp->rd_tlen); | |||
1065 | lp = TAILQ_FIRST(&(plines->l_lines))((&(plines->l_lines))->tqh_first); | |||
1066 | ||||
1067 | /* skip first bogus line */ | |||
1068 | for (lp = TAILQ_NEXT(lp, l_list)((lp)->l_list.tqe_next); lp != NULL((void *)0); | |||
1069 | lp = TAILQ_NEXT(lp, l_list)((lp)->l_list.tqe_next)) { | |||
1070 | if (lp->l_len < 2) | |||
1071 | fatal("line too short, RCS patch seems broken"); | |||
1072 | op = *(lp->l_line); | |||
1073 | /* NUL-terminate line buffer for strtol() safety. */ | |||
1074 | tmp = lp->l_line[lp->l_len - 1]; | |||
1075 | lp->l_line[lp->l_len - 1] = '\0'; | |||
1076 | (void)strtol((lp->l_line + 1), &ep, 10); | |||
1077 | ep++; | |||
1078 | nbln = (int)strtol(ep, &ep, 10); | |||
1079 | /* Restore the last byte of the buffer */ | |||
1080 | lp->l_line[lp->l_len - 1] = tmp; | |||
1081 | if (nbln < 0) | |||
1082 | fatal("invalid line number specification in RCS patch"); | |||
1083 | ||||
1084 | if (op == 'a') { | |||
1085 | added += nbln; | |||
1086 | for (i = 0; i < nbln; i++) { | |||
1087 | lp = TAILQ_NEXT(lp, l_list)((lp)->l_list.tqe_next); | |||
1088 | if (lp == NULL((void *)0)) | |||
1089 | fatal("truncated RCS patch"); | |||
1090 | } | |||
1091 | } | |||
1092 | else if (op == 'd') | |||
1093 | removed += nbln; | |||
1094 | else | |||
1095 | fatal("unknown RCS patch operation '%c'", op); | |||
1096 | } | |||
1097 | ||||
1098 | cvs_freelines(plines); | |||
1099 | ||||
1100 | *ladded = added; | |||
1101 | *lremoved = removed; | |||
1102 | } | |||
1103 | ||||
1104 | /* | |||
1105 | * rcs_rev_add() | |||
1106 | * | |||
1107 | * Add a revision to the RCS file <rf>. The new revision's number can be | |||
1108 | * specified in <rev> (which can also be RCS_HEAD_REV, in which case the | |||
1109 | * new revision will have a number equal to the previous head revision plus | |||
1110 | * one). The <msg> argument specifies the log message for that revision, and | |||
1111 | * <date> specifies the revision's date (a value of -1 is | |||
1112 | * equivalent to using the current time). | |||
1113 | * If <author> is NULL, set the author for this revision to the current user. | |||
1114 | * Returns 0 on success, or -1 on failure. | |||
1115 | */ | |||
1116 | int | |||
1117 | rcs_rev_add(RCSFILE *rf, RCSNUM *rev, const char *msg, time_t date, | |||
1118 | const char *author) | |||
1119 | { | |||
1120 | time_t now; | |||
1121 | RCSNUM *root = NULL((void *)0); | |||
1122 | struct passwd *pw; | |||
1123 | struct rcs_branch *brp, *obrp; | |||
1124 | struct rcs_delta *ordp, *rdp; | |||
1125 | ||||
1126 | if (rev == RCS_HEAD_REV((RCSNUM *)(-1))) { | |||
1127 | if (rf->rf_flags & RCS_CREATE(1<<2)) { | |||
1128 | if ((rev = rcsnum_parse(RCS_HEAD_INIT"1.1")) == NULL((void *)0)) | |||
1129 | return (-1); | |||
1130 | free(rf->rf_head); | |||
1131 | rf->rf_head = rev; | |||
1132 | } else if (rf->rf_head == NULL((void *)0)) { | |||
1133 | return (-1); | |||
1134 | } else { | |||
1135 | rev = rcsnum_inc(rf->rf_head); | |||
1136 | } | |||
1137 | } else { | |||
1138 | if ((rdp = rcs_findrev(rf, rev)) != NULL((void *)0)) | |||
1139 | return (-1); | |||
1140 | } | |||
1141 | ||||
1142 | rdp = xcalloc(1, sizeof(*rdp)); | |||
1143 | ||||
1144 | TAILQ_INIT(&(rdp->rd_branches))do { (&(rdp->rd_branches))->tqh_first = ((void *)0) ; (&(rdp->rd_branches))->tqh_last = &(&(rdp ->rd_branches))->tqh_first; } while (0); | |||
1145 | ||||
1146 | rdp->rd_num = rcsnum_alloc(); | |||
1147 | rcsnum_cpy(rev, rdp->rd_num, 0); | |||
1148 | ||||
1149 | rdp->rd_next = rcsnum_alloc(); | |||
1150 | ||||
1151 | if (!author && !(author = getlogin())) { | |||
1152 | if (!(pw = getpwuid(getuid()))) | |||
1153 | fatal("getpwuid failed"); | |||
1154 | author = pw->pw_name; | |||
1155 | } | |||
1156 | rdp->rd_author = xstrdup(author); | |||
1157 | rdp->rd_state = xstrdup(RCS_STATE_EXP"Exp"); | |||
1158 | rdp->rd_log = xstrdup(msg); | |||
1159 | ||||
1160 | if (date != (time_t)(-1)) | |||
1161 | now = date; | |||
1162 | else | |||
1163 | time(&now); | |||
1164 | gmtime_r(&now, &(rdp->rd_date)); | |||
1165 | ||||
1166 | if (RCSNUM_ISBRANCHREV(rev)(!((rev)->rn_len % 2) && ((rev)->rn_len >= 4 ))) | |||
1167 | TAILQ_INSERT_TAIL(&(rf->rf_delta), rdp, rd_list)do { (rdp)->rd_list.tqe_next = ((void *)0); (rdp)->rd_list .tqe_prev = (&(rf->rf_delta))->tqh_last; *(&(rf ->rf_delta))->tqh_last = (rdp); (&(rf->rf_delta) )->tqh_last = &(rdp)->rd_list.tqe_next; } while (0); | |||
1168 | else | |||
1169 | TAILQ_INSERT_HEAD(&(rf->rf_delta), rdp, rd_list)do { if (((rdp)->rd_list.tqe_next = (&(rf->rf_delta ))->tqh_first) != ((void *)0)) (&(rf->rf_delta))-> tqh_first->rd_list.tqe_prev = &(rdp)->rd_list.tqe_next ; else (&(rf->rf_delta))->tqh_last = &(rdp)-> rd_list.tqe_next; (&(rf->rf_delta))->tqh_first = (rdp ); (rdp)->rd_list.tqe_prev = &(&(rf->rf_delta)) ->tqh_first; } while (0); | |||
1170 | rf->rf_ndelta++; | |||
1171 | ||||
1172 | if (!(rf->rf_flags & RCS_CREATE(1<<2))) { | |||
1173 | if (RCSNUM_ISBRANCHREV(rev)(!((rev)->rn_len % 2) && ((rev)->rn_len >= 4 ))) { | |||
1174 | if (rev->rn_id[rev->rn_len - 1] == 1) { | |||
1175 | /* a new branch */ | |||
1176 | root = rcsnum_branch_root(rev); | |||
1177 | brp = xmalloc(sizeof(*brp)); | |||
1178 | brp->rb_num = rcsnum_alloc(); | |||
1179 | rcsnum_cpy(rdp->rd_num, brp->rb_num, 0); | |||
1180 | ||||
1181 | if ((ordp = rcs_findrev(rf, root)) == NULL((void *)0)) | |||
1182 | fatal("root node not found"); | |||
1183 | ||||
1184 | TAILQ_FOREACH(obrp, &(ordp->rd_branches),for((obrp) = ((&(ordp->rd_branches))->tqh_first); ( obrp) != ((void *)0); (obrp) = ((obrp)->rb_list.tqe_next)) | |||
1185 | rb_list)for((obrp) = ((&(ordp->rd_branches))->tqh_first); ( obrp) != ((void *)0); (obrp) = ((obrp)->rb_list.tqe_next)) { | |||
1186 | if (!rcsnum_cmp(obrp->rb_num, | |||
1187 | brp->rb_num, | |||
1188 | brp->rb_num->rn_len - 1)) | |||
1189 | break; | |||
1190 | } | |||
1191 | ||||
1192 | if (obrp == NULL((void *)0)) { | |||
1193 | TAILQ_INSERT_TAIL(&(ordp->rd_branches),do { (brp)->rb_list.tqe_next = ((void *)0); (brp)->rb_list .tqe_prev = (&(ordp->rd_branches))->tqh_last; *(& (ordp->rd_branches))->tqh_last = (brp); (&(ordp-> rd_branches))->tqh_last = &(brp)->rb_list.tqe_next; } while (0) | |||
1194 | brp, rb_list)do { (brp)->rb_list.tqe_next = ((void *)0); (brp)->rb_list .tqe_prev = (&(ordp->rd_branches))->tqh_last; *(& (ordp->rd_branches))->tqh_last = (brp); (&(ordp-> rd_branches))->tqh_last = &(brp)->rb_list.tqe_next; } while (0); | |||
1195 | } | |||
1196 | } else { | |||
1197 | root = rcsnum_alloc(); | |||
1198 | rcsnum_cpy(rev, root, 0); | |||
1199 | rcsnum_dec(root); | |||
1200 | if ((ordp = rcs_findrev(rf, root)) == NULL((void *)0)) | |||
1201 | fatal("previous revision not found"); | |||
1202 | rcsnum_cpy(rdp->rd_num, ordp->rd_next, 0); | |||
1203 | } | |||
1204 | } else { | |||
1205 | ordp = TAILQ_NEXT(rdp, rd_list)((rdp)->rd_list.tqe_next); | |||
1206 | rcsnum_cpy(ordp->rd_num, rdp->rd_next, 0); | |||
1207 | } | |||
1208 | } | |||
1209 | ||||
1210 | free(root); | |||
1211 | ||||
1212 | /* not synced anymore */ | |||
1213 | rf->rf_flags &= ~RCS_SYNCED(1<<5); | |||
1214 | ||||
1215 | return (0); | |||
1216 | } | |||
1217 | ||||
1218 | /* | |||
1219 | * rcs_rev_remove() | |||
1220 | * | |||
1221 | * Remove the revision whose number is <rev> from the RCS file <rf>. | |||
1222 | */ | |||
1223 | int | |||
1224 | rcs_rev_remove(RCSFILE *rf, RCSNUM *rev) | |||
1225 | { | |||
1226 | int fd1, fd2; | |||
1227 | char *path_tmp1, *path_tmp2; | |||
1228 | struct rcs_delta *rdp, *prevrdp, *nextrdp; | |||
1229 | BUF *prevbuf, *newdiff, *newdeltatext; | |||
1230 | ||||
1231 | if (rev == RCS_HEAD_REV((RCSNUM *)(-1))) | |||
1232 | rev = rf->rf_head; | |||
1233 | ||||
1234 | if (rev == NULL((void *)0)) | |||
1235 | return (-1); | |||
1236 | ||||
1237 | /* do we actually have that revision? */ | |||
1238 | if ((rdp = rcs_findrev(rf, rev)) == NULL((void *)0)) | |||
1239 | return (-1); | |||
1240 | ||||
1241 | /* | |||
1242 | * This is confusing, the previous delta is next in the TAILQ list. | |||
1243 | * the next delta is the previous one in the TAILQ list. | |||
1244 | * | |||
1245 | * When the HEAD revision got specified, nextrdp will be NULL. | |||
1246 | * When the first revision got specified, prevrdp will be NULL. | |||
1247 | */ | |||
1248 | prevrdp = (struct rcs_delta *)TAILQ_NEXT(rdp, rd_list)((rdp)->rd_list.tqe_next); | |||
1249 | nextrdp = (struct rcs_delta *)TAILQ_PREV(rdp, tqh, rd_list)(*(((struct tqh *)((rdp)->rd_list.tqe_prev))->tqh_last) ); | |||
1250 | ||||
1251 | newdeltatext = NULL((void *)0); | |||
1252 | prevbuf = NULL((void *)0); | |||
1253 | path_tmp1 = path_tmp2 = NULL((void *)0); | |||
1254 | ||||
1255 | if (prevrdp != NULL((void *)0) && nextrdp != NULL((void *)0)) { | |||
1256 | newdiff = buf_alloc(64); | |||
1257 | ||||
1258 | /* calculate new diff */ | |||
1259 | (void)xasprintf(&path_tmp1, "%s/diff1.XXXXXXXXXX", cvs_tmpdir); | |||
1260 | fd1 = rcs_rev_write_stmp(rf, nextrdp->rd_num, path_tmp1, 0); | |||
1261 | ||||
1262 | (void)xasprintf(&path_tmp2, "%s/diff2.XXXXXXXXXX", cvs_tmpdir); | |||
1263 | fd2 = rcs_rev_write_stmp(rf, prevrdp->rd_num, path_tmp2, 0); | |||
1264 | ||||
1265 | diff_format = D_RCSDIFF5; | |||
1266 | if (diffreg(path_tmp1, path_tmp2, | |||
1267 | fd1, fd2, newdiff, D_FORCEASCII0x01) == D_ERROR7) | |||
1268 | fatal("rcs_diffreg failed"); | |||
1269 | ||||
1270 | close(fd1); | |||
1271 | close(fd2); | |||
1272 | ||||
1273 | newdeltatext = newdiff; | |||
1274 | } else if (nextrdp == NULL((void *)0) && prevrdp != NULL((void *)0)) { | |||
1275 | newdeltatext = prevbuf; | |||
1276 | } | |||
1277 | ||||
1278 | if (newdeltatext != NULL((void *)0)) { | |||
1279 | if (rcs_deltatext_set(rf, prevrdp->rd_num, newdeltatext) < 0) | |||
1280 | fatal("error setting new deltatext"); | |||
1281 | } | |||
1282 | ||||
1283 | TAILQ_REMOVE(&(rf->rf_delta), rdp, rd_list)do { if (((rdp)->rd_list.tqe_next) != ((void *)0)) (rdp)-> rd_list.tqe_next->rd_list.tqe_prev = (rdp)->rd_list.tqe_prev ; else (&(rf->rf_delta))->tqh_last = (rdp)->rd_list .tqe_prev; *(rdp)->rd_list.tqe_prev = (rdp)->rd_list.tqe_next ; ; ; } while (0); | |||
1284 | ||||
1285 | /* update pointers */ | |||
1286 | if (prevrdp != NULL((void *)0) && nextrdp != NULL((void *)0)) { | |||
1287 | rcsnum_cpy(prevrdp->rd_num, nextrdp->rd_next, 0); | |||
1288 | } else if (prevrdp != NULL((void *)0)) { | |||
1289 | if (rcs_head_set(rf, prevrdp->rd_num) < 0) | |||
1290 | fatal("rcs_head_set failed"); | |||
1291 | } else if (nextrdp != NULL((void *)0)) { | |||
1292 | free(nextrdp->rd_next); | |||
1293 | nextrdp->rd_next = rcsnum_alloc(); | |||
1294 | } else { | |||
1295 | free(rf->rf_head); | |||
1296 | rf->rf_head = NULL((void *)0); | |||
1297 | } | |||
1298 | ||||
1299 | rf->rf_ndelta--; | |||
1300 | rf->rf_flags &= ~RCS_SYNCED(1<<5); | |||
1301 | ||||
1302 | rcs_freedelta(rdp); | |||
1303 | free(newdeltatext); | |||
1304 | free(path_tmp1); | |||
1305 | free(path_tmp2); | |||
1306 | ||||
1307 | return (0); | |||
1308 | } | |||
1309 | ||||
1310 | /* | |||
1311 | * rcs_findrev() | |||
1312 | * | |||
1313 | * Find a specific revision's delta entry in the tree of the RCS file <rfp>. | |||
1314 | * The revision number is given in <rev>. | |||
1315 | * | |||
1316 | * Returns a pointer to the delta on success, or NULL on failure. | |||
1317 | */ | |||
1318 | struct rcs_delta * | |||
1319 | rcs_findrev(RCSFILE *rfp, RCSNUM *rev) | |||
1320 | { | |||
1321 | int isbrev; | |||
1322 | struct rcs_delta *rdp; | |||
1323 | ||||
1324 | if (rev == NULL((void *)0)) | |||
1325 | return NULL((void *)0); | |||
1326 | ||||
1327 | isbrev = RCSNUM_ISBRANCHREV(rev)(!((rev)->rn_len % 2) && ((rev)->rn_len >= 4 )); | |||
1328 | ||||
1329 | /* | |||
1330 | * We need to do more parsing if the last revision in the linked list | |||
1331 | * is greater than the requested revision. | |||
1332 | */ | |||
1333 | rdp = TAILQ_LAST(&(rfp->rf_delta), rcs_dlist)(*(((struct rcs_dlist *)((&(rfp->rf_delta))->tqh_last ))->tqh_last)); | |||
1334 | if (rdp == NULL((void *)0) || | |||
1335 | (!isbrev && rcsnum_cmp(rdp->rd_num, rev, 0) == -1) || | |||
1336 | ((isbrev && rdp->rd_num->rn_len < 4) || | |||
1337 | (isbrev && rcsnum_differ(rev, rdp->rd_num)))) { | |||
1338 | if (rcsparse_deltas(rfp, rev)) | |||
1339 | fatal("error parsing deltas"); | |||
1340 | } | |||
1341 | ||||
1342 | TAILQ_FOREACH(rdp, &(rfp->rf_delta), rd_list)for((rdp) = ((&(rfp->rf_delta))->tqh_first); (rdp) != ((void *)0); (rdp) = ((rdp)->rd_list.tqe_next)) { | |||
1343 | if (rcsnum_differ(rdp->rd_num, rev)) | |||
1344 | continue; | |||
1345 | else | |||
1346 | return (rdp); | |||
1347 | } | |||
1348 | ||||
1349 | return (NULL((void *)0)); | |||
1350 | } | |||
1351 | ||||
1352 | /* | |||
1353 | * rcs_kwexp_set() | |||
1354 | * | |||
1355 | * Set the keyword expansion mode to use on the RCS file <file> to <mode>. | |||
1356 | */ | |||
1357 | void | |||
1358 | rcs_kwexp_set(RCSFILE *file, int mode) | |||
1359 | { | |||
1360 | int i; | |||
1361 | char *tmp, buf[8] = ""; | |||
1362 | ||||
1363 | if (RCS_KWEXP_INVAL(mode)((mode & 0x20) || ((mode & 0x10) && (mode & ~0x10)))) | |||
1364 | return; | |||
1365 | ||||
1366 | i = 0; | |||
1367 | if (mode == RCS_KWEXP_NONE0x01) | |||
1368 | buf[0] = 'b'; | |||
1369 | else if (mode == RCS_KWEXP_OLD0x10) | |||
1370 | buf[0] = 'o'; | |||
1371 | else { | |||
1372 | if (mode & RCS_KWEXP_NAME0x02) | |||
1373 | buf[i++] = 'k'; | |||
1374 | if (mode & RCS_KWEXP_VAL0x04) | |||
1375 | buf[i++] = 'v'; | |||
1376 | if (mode & RCS_KWEXP_LKR0x08) | |||
1377 | buf[i++] = 'l'; | |||
1378 | } | |||
1379 | ||||
1380 | tmp = xstrdup(buf); | |||
1381 | free(file->rf_expand); | |||
1382 | file->rf_expand = tmp; | |||
1383 | /* not synced anymore */ | |||
1384 | file->rf_flags &= ~RCS_SYNCED(1<<5); | |||
1385 | } | |||
1386 | ||||
1387 | /* | |||
1388 | * rcs_kwexp_get() | |||
1389 | * | |||
1390 | * Retrieve the keyword expansion mode to be used for the RCS file <file>. | |||
1391 | */ | |||
1392 | int | |||
1393 | rcs_kwexp_get(RCSFILE *file) | |||
1394 | { | |||
1395 | if (file->rf_expand == NULL((void *)0)) | |||
1396 | return (RCS_KWEXP_DEFAULT(0x02 | 0x04)); | |||
1397 | ||||
1398 | return (rcs_kflag_get(file->rf_expand)); | |||
1399 | } | |||
1400 | ||||
1401 | /* | |||
1402 | * rcs_kflag_get() | |||
1403 | * | |||
1404 | * Get the keyword expansion mode from a set of character flags given in | |||
1405 | * <flags> and return the appropriate flag mask. In case of an error, the | |||
1406 | * returned mask will have the RCS_KWEXP_ERR bit set to 1. | |||
1407 | */ | |||
1408 | int | |||
1409 | rcs_kflag_get(const char *flags) | |||
1410 | { | |||
1411 | int fl; | |||
1412 | size_t len; | |||
1413 | const char *fp; | |||
1414 | ||||
1415 | if (flags == NULL((void *)0) || !(len = strlen(flags))) | |||
1416 | return (RCS_KWEXP_ERR0x20); | |||
1417 | ||||
1418 | fl = 0; | |||
1419 | for (fp = flags; *fp != '\0'; fp++) { | |||
1420 | if (*fp == 'k') | |||
1421 | fl |= RCS_KWEXP_NAME0x02; | |||
1422 | else if (*fp == 'v') | |||
1423 | fl |= RCS_KWEXP_VAL0x04; | |||
1424 | else if (*fp == 'l') | |||
1425 | fl |= RCS_KWEXP_LKR0x08; | |||
1426 | else if (*fp == 'o') { | |||
1427 | if (len != 1) | |||
1428 | fl |= RCS_KWEXP_ERR0x20; | |||
1429 | fl |= RCS_KWEXP_OLD0x10; | |||
1430 | } else if (*fp == 'b') { | |||
1431 | if (len != 1) | |||
1432 | fl |= RCS_KWEXP_ERR0x20; | |||
1433 | fl |= RCS_KWEXP_NONE0x01; | |||
1434 | } else /* unknown letter */ | |||
1435 | fl |= RCS_KWEXP_ERR0x20; | |||
1436 | } | |||
1437 | ||||
1438 | return (fl); | |||
1439 | } | |||
1440 | ||||
1441 | /* | |||
1442 | * rcs_freedelta() | |||
1443 | * | |||
1444 | * Free the contents of a delta structure. | |||
1445 | */ | |||
1446 | static void | |||
1447 | rcs_freedelta(struct rcs_delta *rdp) | |||
1448 | { | |||
1449 | struct rcs_branch *rb; | |||
1450 | ||||
1451 | free(rdp->rd_num); | |||
1452 | free(rdp->rd_next); | |||
1453 | free(rdp->rd_author); | |||
1454 | free(rdp->rd_locker); | |||
1455 | free(rdp->rd_state); | |||
1456 | free(rdp->rd_log); | |||
1457 | free(rdp->rd_text); | |||
1458 | ||||
1459 | while ((rb = TAILQ_FIRST(&(rdp->rd_branches))((&(rdp->rd_branches))->tqh_first)) != NULL((void *)0)) { | |||
1460 | TAILQ_REMOVE(&(rdp->rd_branches), rb, rb_list)do { if (((rb)->rb_list.tqe_next) != ((void *)0)) (rb)-> rb_list.tqe_next->rb_list.tqe_prev = (rb)->rb_list.tqe_prev ; else (&(rdp->rd_branches))->tqh_last = (rb)->rb_list .tqe_prev; *(rb)->rb_list.tqe_prev = (rb)->rb_list.tqe_next ; ; ; } while (0); | |||
1461 | free(rb->rb_num); | |||
1462 | free(rb); | |||
1463 | } | |||
1464 | ||||
1465 | free(rdp); | |||
1466 | } | |||
1467 | ||||
1468 | /* | |||
1469 | * rcs_strprint() | |||
1470 | * | |||
1471 | * Output an RCS string <str> of size <slen> to the stream <stream>. Any | |||
1472 | * '@' characters are escaped. Otherwise, the string can contain arbitrary | |||
1473 | * binary data. | |||
1474 | */ | |||
1475 | static void | |||
1476 | rcs_strprint(const u_char *str, size_t slen, FILE *stream) | |||
1477 | { | |||
1478 | const u_char *ap, *ep, *sp; | |||
1479 | ||||
1480 | if (slen == 0) | |||
1481 | return; | |||
1482 | ||||
1483 | ep = str + slen - 1; | |||
1484 | ||||
1485 | for (sp = str; sp <= ep;) { | |||
1486 | ap = memchr(sp, '@', ep - sp); | |||
1487 | if (ap == NULL((void *)0)) | |||
1488 | ap = ep; | |||
1489 | (void)fwrite(sp, sizeof(u_char), ap - sp + 1, stream); | |||
1490 | ||||
1491 | if (*ap == '@') | |||
1492 | putc('@', stream)(!__isthreaded ? __sputc('@', stream) : (putc)('@', stream)); | |||
1493 | sp = ap + 1; | |||
1494 | } | |||
1495 | } | |||
1496 | ||||
1497 | /* | |||
1498 | * rcs_deltatext_set() | |||
1499 | * | |||
1500 | * Set deltatext for <rev> in RCS file <rfp> to <dtext> | |||
1501 | * Returns -1 on error, 0 on success. | |||
1502 | */ | |||
1503 | int | |||
1504 | rcs_deltatext_set(RCSFILE *rfp, RCSNUM *rev, BUF *bp) | |||
1505 | { | |||
1506 | size_t len; | |||
1507 | u_char *dtext; | |||
1508 | struct rcs_delta *rdp; | |||
1509 | ||||
1510 | /* Write operations require full parsing */ | |||
1511 | if (rcsparse_deltatexts(rfp, NULL((void *)0))) | |||
1512 | return (-1); | |||
1513 | ||||
1514 | if ((rdp = rcs_findrev(rfp, rev)) == NULL((void *)0)) | |||
1515 | return (-1); | |||
1516 | ||||
1517 | free(rdp->rd_text); | |||
1518 | ||||
1519 | len = buf_len(bp); | |||
1520 | dtext = buf_release(bp); | |||
1521 | bp = NULL((void *)0); | |||
1522 | ||||
1523 | if (len != 0) { | |||
1524 | rdp->rd_text = xmalloc(len); | |||
1525 | rdp->rd_tlen = len; | |||
1526 | (void)memcpy(rdp->rd_text, dtext, len); | |||
1527 | } else { | |||
1528 | rdp->rd_text = NULL((void *)0); | |||
1529 | rdp->rd_tlen = 0; | |||
1530 | } | |||
1531 | ||||
1532 | free(dtext); | |||
1533 | return (0); | |||
1534 | } | |||
1535 | ||||
1536 | /* | |||
1537 | * rcs_rev_setlog() | |||
1538 | * | |||
1539 | * Sets the log message of revision <rev> to <logtext>. | |||
1540 | */ | |||
1541 | int | |||
1542 | rcs_rev_setlog(RCSFILE *rfp, RCSNUM *rev, const char *logtext) | |||
1543 | { | |||
1544 | struct rcs_delta *rdp; | |||
1545 | ||||
1546 | if ((rdp = rcs_findrev(rfp, rev)) == NULL((void *)0)) | |||
1547 | return (-1); | |||
1548 | ||||
1549 | free(rdp->rd_log); | |||
1550 | ||||
1551 | rdp->rd_log = xstrdup(logtext); | |||
1552 | rfp->rf_flags &= ~RCS_SYNCED(1<<5); | |||
1553 | return (0); | |||
1554 | } | |||
1555 | /* | |||
1556 | * rcs_rev_getdate() | |||
1557 | * | |||
1558 | * Get the date corresponding to a given revision. | |||
1559 | * Returns the date on success, -1 on failure. | |||
1560 | */ | |||
1561 | time_t | |||
1562 | rcs_rev_getdate(RCSFILE *rfp, RCSNUM *rev) | |||
1563 | { | |||
1564 | struct rcs_delta *rdp; | |||
1565 | ||||
1566 | if ((rdp = rcs_findrev(rfp, rev)) == NULL((void *)0)) | |||
1567 | return (-1); | |||
1568 | ||||
1569 | return (timegm(&rdp->rd_date)); | |||
1570 | } | |||
1571 | ||||
1572 | /* | |||
1573 | * rcs_state_set() | |||
1574 | * | |||
1575 | * Sets the state of revision <rev> to <state> | |||
1576 | * NOTE: default state is 'Exp'. States may not contain spaces. | |||
1577 | * | |||
1578 | * Returns -1 on failure, 0 on success. | |||
1579 | */ | |||
1580 | int | |||
1581 | rcs_state_set(RCSFILE *rfp, RCSNUM *rev, const char *state) | |||
1582 | { | |||
1583 | struct rcs_delta *rdp; | |||
1584 | ||||
1585 | if ((rdp = rcs_findrev(rfp, rev)) == NULL((void *)0)) | |||
1586 | return (-1); | |||
1587 | ||||
1588 | free(rdp->rd_state); | |||
1589 | ||||
1590 | rdp->rd_state = xstrdup(state); | |||
1591 | ||||
1592 | rfp->rf_flags &= ~RCS_SYNCED(1<<5); | |||
1593 | ||||
1594 | return (0); | |||
1595 | } | |||
1596 | ||||
1597 | /* | |||
1598 | * rcs_state_check() | |||
1599 | * | |||
1600 | * Check if string <state> is valid. | |||
1601 | * | |||
1602 | * Returns 0 if the string is valid, -1 otherwise. | |||
1603 | */ | |||
1604 | int | |||
1605 | rcs_state_check(const char *state) | |||
1606 | { | |||
1607 | if (strcmp(state, RCS_STATE_DEAD"dead") && strcmp(state, RCS_STATE_EXP"Exp")) | |||
1608 | return (-1); | |||
1609 | ||||
1610 | return (0); | |||
1611 | } | |||
1612 | ||||
1613 | /* | |||
1614 | * rcs_state_get() | |||
1615 | * | |||
1616 | * Get the state for a given revision of a specified RCSFILE. | |||
1617 | * | |||
1618 | * Returns NULL on failure. | |||
1619 | */ | |||
1620 | const char * | |||
1621 | rcs_state_get(RCSFILE *rfp, RCSNUM *rev) | |||
1622 | { | |||
1623 | struct rcs_delta *rdp; | |||
1624 | ||||
1625 | if ((rdp = rcs_findrev(rfp, rev)) == NULL((void *)0)) | |||
1626 | return (NULL((void *)0)); | |||
1627 | ||||
1628 | return (rdp->rd_state); | |||
1629 | } | |||
1630 | ||||
1631 | /* rcs_get_revision() */ | |||
1632 | static RCSNUM * | |||
1633 | rcs_get_revision(const char *revstr, RCSFILE *rfp) | |||
1634 | { | |||
1635 | RCSNUM *rev, *brev, *frev; | |||
1636 | struct rcs_branch *brp; | |||
1637 | struct rcs_delta *rdp; | |||
1638 | size_t i; | |||
1639 | ||||
1640 | rdp = NULL((void *)0); | |||
1641 | ||||
1642 | if (!strcmp(revstr, RCS_HEAD_BRANCH"HEAD")) { | |||
1643 | if (rfp->rf_head == NULL((void *)0)) | |||
1644 | return (NULL((void *)0)); | |||
1645 | ||||
1646 | frev = rcsnum_alloc(); | |||
1647 | rcsnum_cpy(rfp->rf_head, frev, 0); | |||
1648 | return (frev); | |||
1649 | } | |||
1650 | ||||
1651 | /* Possibly we could be passed a version number */ | |||
1652 | if ((rev = rcsnum_parse(revstr)) != NULL((void *)0)) { | |||
1653 | /* Do not return if it is not in RCS file */ | |||
1654 | if ((rdp = rcs_findrev(rfp, rev)) != NULL((void *)0)) | |||
1655 | return (rev); | |||
1656 | } else { | |||
1657 | /* More likely we will be passed a symbol */ | |||
1658 | rev = rcs_sym_getrev(rfp, revstr); | |||
1659 | } | |||
1660 | ||||
1661 | if (rev == NULL((void *)0)) | |||
1662 | return (NULL((void *)0)); | |||
1663 | ||||
1664 | /* | |||
1665 | * If it was not a branch, thats ok the symbolic | |||
1666 | * name refered to a revision, so return the resolved | |||
1667 | * revision for the given name. */ | |||
1668 | if (!RCSNUM_ISBRANCH(rev)((rev)->rn_len % 2)) { | |||
1669 | /* Sanity check: The first two elements of any | |||
1670 | * revision (be it on a branch or on trunk) cannot | |||
1671 | * be greater than HEAD. | |||
1672 | * | |||
1673 | * XXX: To avoid comparing to uninitialized memory, | |||
1674 | * the minimum of both revision lengths is taken | |||
1675 | * instead of just 2. | |||
1676 | */ | |||
1677 | if (rfp->rf_head == NULL((void *)0) || rcsnum_cmp(rev, rfp->rf_head, | |||
1678 | MINIMUM(rfp->rf_head->rn_len, rev->rn_len)(((rfp->rf_head->rn_len) < (rev->rn_len)) ? (rfp-> rf_head->rn_len) : (rev->rn_len))) < 0) { | |||
1679 | free(rev); | |||
1680 | return (NULL((void *)0)); | |||
1681 | } | |||
1682 | return (rev); | |||
1683 | } | |||
1684 | ||||
1685 | brev = rcsnum_alloc(); | |||
1686 | rcsnum_cpy(rev, brev, rev->rn_len - 1); | |||
1687 | ||||
1688 | if ((rdp = rcs_findrev(rfp, brev)) == NULL((void *)0)) | |||
1689 | fatal("rcs_get_revision: tag `%s' does not exist", revstr); | |||
1690 | free(brev); | |||
1691 | ||||
1692 | TAILQ_FOREACH(brp, &(rdp->rd_branches), rb_list)for((brp) = ((&(rdp->rd_branches))->tqh_first); (brp ) != ((void *)0); (brp) = ((brp)->rb_list.tqe_next)) { | |||
1693 | for (i = 0; i < rev->rn_len; i++) | |||
1694 | if (brp->rb_num->rn_id[i] != rev->rn_id[i]) | |||
1695 | break; | |||
1696 | if (i != rev->rn_len) | |||
1697 | continue; | |||
1698 | break; | |||
1699 | } | |||
1700 | ||||
1701 | free(rev); | |||
1702 | frev = rcsnum_alloc(); | |||
1703 | if (brp == NULL((void *)0)) { | |||
1704 | rcsnum_cpy(rdp->rd_num, frev, 0); | |||
1705 | return (frev); | |||
1706 | } else { | |||
1707 | /* Fetch the delta with the correct branch num */ | |||
1708 | if ((rdp = rcs_findrev(rfp, brp->rb_num)) == NULL((void *)0)) | |||
1709 | fatal("rcs_get_revision: could not fetch branch " | |||
1710 | "delta"); | |||
1711 | rcsnum_cpy(rdp->rd_num, frev, 0); | |||
1712 | return (frev); | |||
1713 | } | |||
1714 | } | |||
1715 | ||||
1716 | /* | |||
1717 | * rcs_rev_getlines() | |||
1718 | * | |||
1719 | * Get the entire contents of revision <frev> from the RCSFILE <rfp> and | |||
1720 | * return it as a pointer to a struct rcs_lines. | |||
1721 | */ | |||
1722 | struct rcs_lines * | |||
1723 | rcs_rev_getlines(RCSFILE *rfp, RCSNUM *frev, struct rcs_line ***alines) | |||
1724 | { | |||
1725 | size_t plen; | |||
1726 | int annotate, done, i, nextroot; | |||
1727 | RCSNUM *tnum, *bnum; | |||
1728 | struct rcs_branch *brp; | |||
1729 | struct rcs_delta *hrdp, *prdp, *rdp, *trdp; | |||
1730 | u_char *patch; | |||
1731 | struct rcs_line *line, *nline; | |||
1732 | struct rcs_lines *dlines, *plines; | |||
1733 | ||||
1734 | hrdp = prdp = rdp = trdp = NULL((void *)0); | |||
1735 | ||||
1736 | if (rfp->rf_head == NULL((void *)0) || | |||
1737 | (hrdp = rcs_findrev(rfp, rfp->rf_head)) == NULL((void *)0)) | |||
1738 | fatal("rcs_rev_getlines: no HEAD revision"); | |||
1739 | ||||
1740 | tnum = frev; | |||
1741 | if (rcsparse_deltatexts(rfp, hrdp->rd_num)) | |||
1742 | fatal("rcs_rev_getlines: rcsparse_deltatexts"); | |||
1743 | ||||
1744 | /* revision on branch, get the branch root */ | |||
1745 | nextroot = 2; | |||
1746 | bnum = rcsnum_alloc(); | |||
1747 | if (RCSNUM_ISBRANCHREV(tnum)(!((tnum)->rn_len % 2) && ((tnum)->rn_len >= 4))) | |||
1748 | rcsnum_cpy(tnum, bnum, nextroot); | |||
1749 | else | |||
1750 | rcsnum_cpy(tnum, bnum, tnum->rn_len); | |||
1751 | ||||
1752 | if (alines
| |||
1753 | /* start with annotate first at requested revision */ | |||
1754 | annotate = ANNOTATE_LATER2; | |||
1755 | *alines = NULL((void *)0); | |||
1756 | } else | |||
1757 | annotate = ANNOTATE_NEVER0; | |||
1758 | ||||
1759 | dlines = cvs_splitlines(hrdp->rd_text, hrdp->rd_tlen); | |||
1760 | ||||
1761 | done = 0; | |||
1762 | ||||
1763 | rdp = hrdp; | |||
1764 | if (!rcsnum_differ(rdp->rd_num, bnum)) { | |||
1765 | if (annotate == ANNOTATE_LATER2) { | |||
1766 | /* found requested revision for annotate */ | |||
1767 | i = 0; | |||
1768 | TAILQ_FOREACH(line, &(dlines->l_lines), l_list)for((line) = ((&(dlines->l_lines))->tqh_first); (line ) != ((void *)0); (line) = ((line)->l_list.tqe_next)) { | |||
1769 | line->l_lineno_orig = line->l_lineno; | |||
1770 | i++; | |||
1771 | } | |||
1772 | ||||
1773 | *alines = xcalloc(i + 1, sizeof(struct rcs_line *)); | |||
1774 | (*alines)[i] = NULL((void *)0); | |||
1775 | annotate = ANNOTATE_NOW1; | |||
1776 | ||||
1777 | /* annotate down to 1.1 from where we are */ | |||
1778 | free(bnum); | |||
1779 | bnum = rcsnum_parse("1.1"); | |||
1780 | if (!rcsnum_differ(rdp->rd_num, bnum)) { | |||
1781 | goto next; | |||
1782 | } | |||
1783 | } else | |||
1784 | goto next; | |||
1785 | } | |||
1786 | ||||
1787 | prdp = hrdp; | |||
1788 | if ((rdp = rcs_findrev(rfp, hrdp->rd_next)) == NULL((void *)0)) | |||
1789 | goto done; | |||
1790 | ||||
1791 | again: | |||
1792 | while (rdp
| |||
1793 | if (rdp->rd_next->rn_len != 0) { | |||
1794 | trdp = rcs_findrev(rfp, rdp->rd_next); | |||
1795 | if (trdp == NULL((void *)0)) | |||
1796 | fatal("failed to grab next revision"); | |||
1797 | } | |||
1798 | ||||
1799 | if (rdp->rd_tlen == 0) { | |||
1800 | if (rcsparse_deltatexts(rfp, rdp->rd_num)) | |||
1801 | fatal("rcs_rev_getlines: rcsparse_deltatexts"); | |||
1802 | if (rdp->rd_tlen == 0) { | |||
1803 | if (!rcsnum_differ(rdp->rd_num, bnum)) | |||
1804 | break; | |||
1805 | rdp = trdp; | |||
1806 | continue; | |||
1807 | } | |||
1808 | } | |||
1809 | ||||
1810 | plen = rdp->rd_tlen; | |||
1811 | patch = rdp->rd_text; | |||
1812 | plines = cvs_splitlines(patch, plen); | |||
1813 | if (annotate
| |||
1814 | rcs_patch_lines(dlines, plines, *alines, prdp); | |||
1815 | else | |||
1816 | rcs_patch_lines(dlines, plines, NULL((void *)0), NULL((void *)0)); | |||
1817 | cvs_freelines(plines); | |||
1818 | ||||
1819 | if (!rcsnum_differ(rdp->rd_num, bnum)) { | |||
1820 | if (annotate != ANNOTATE_LATER2) | |||
1821 | break; | |||
1822 | ||||
1823 | /* found requested revision for annotate */ | |||
1824 | i = 0; | |||
1825 | TAILQ_FOREACH(line, &(dlines->l_lines), l_list)for((line) = ((&(dlines->l_lines))->tqh_first); (line ) != ((void *)0); (line) = ((line)->l_list.tqe_next)) { | |||
1826 | line->l_lineno_orig = line->l_lineno; | |||
1827 | i++; | |||
1828 | } | |||
1829 | ||||
1830 | *alines = xcalloc(i + 1, sizeof(struct rcs_line *)); | |||
1831 | (*alines)[i] = NULL((void *)0); | |||
1832 | annotate = ANNOTATE_NOW1; | |||
1833 | ||||
1834 | /* annotate down to 1.1 from where we are */ | |||
1835 | free(bnum); | |||
1836 | bnum = rcsnum_parse("1.1"); | |||
1837 | ||||
1838 | if (!rcsnum_differ(rdp->rd_num, bnum)) | |||
1839 | break; | |||
1840 | } | |||
1841 | ||||
1842 | prdp = rdp; | |||
1843 | rdp = trdp; | |||
1844 | } | |||
1845 | ||||
1846 | next: | |||
1847 | if (rdp == NULL((void *)0) || !rcsnum_differ(rdp->rd_num, frev)) | |||
1848 | done = 1; | |||
1849 | ||||
1850 | if (RCSNUM_ISBRANCHREV(frev)(!((frev)->rn_len % 2) && ((frev)->rn_len >= 4)) && done != 1) { | |||
1851 | nextroot += 2; | |||
1852 | rcsnum_cpy(frev, bnum, nextroot); | |||
1853 | ||||
1854 | TAILQ_FOREACH(brp, &(rdp->rd_branches), rb_list)for((brp) = ((&(rdp->rd_branches))->tqh_first); (brp ) != ((void *)0); (brp) = ((brp)->rb_list.tqe_next)) { | |||
1855 | for (i = 0; i < nextroot - 1; i++) | |||
1856 | if (brp->rb_num->rn_id[i] != bnum->rn_id[i]) | |||
1857 | break; | |||
1858 | if (i == nextroot - 1) | |||
1859 | break; | |||
1860 | } | |||
1861 | ||||
1862 | if (brp == NULL((void *)0)) { | |||
1863 | if (annotate != ANNOTATE_NEVER0) { | |||
1864 | free(*alines); | |||
1865 | *alines = NULL((void *)0); | |||
1866 | cvs_freelines(dlines); | |||
1867 | free(bnum); | |||
1868 | return (NULL((void *)0)); | |||
1869 | } | |||
1870 | fatal("expected branch not found on branch list"); | |||
1871 | } | |||
1872 | ||||
1873 | if ((rdp = rcs_findrev(rfp, brp->rb_num)) == NULL((void *)0)) | |||
1874 | fatal("rcs_rev_getlines: failed to get delta for target rev"); | |||
1875 | ||||
1876 | goto again; | |||
1877 | } | |||
1878 | done: | |||
1879 | /* put remaining lines into annotate buffer */ | |||
1880 | if (annotate == ANNOTATE_NOW1) { | |||
1881 | for (line = TAILQ_FIRST(&(dlines->l_lines))((&(dlines->l_lines))->tqh_first); | |||
1882 | line != NULL((void *)0); line = nline) { | |||
1883 | nline = TAILQ_NEXT(line, l_list)((line)->l_list.tqe_next); | |||
1884 | TAILQ_REMOVE(&(dlines->l_lines), line, l_list)do { if (((line)->l_list.tqe_next) != ((void *)0)) (line)-> l_list.tqe_next->l_list.tqe_prev = (line)->l_list.tqe_prev ; else (&(dlines->l_lines))->tqh_last = (line)-> l_list.tqe_prev; *(line)->l_list.tqe_prev = (line)->l_list .tqe_next; ; ; } while (0); | |||
1885 | if (line->l_line == NULL((void *)0)) { | |||
1886 | free(line); | |||
1887 | continue; | |||
1888 | } | |||
1889 | ||||
1890 | line->l_delta = rdp; | |||
1891 | (*alines)[line->l_lineno_orig - 1] = line; | |||
1892 | } | |||
1893 | ||||
1894 | cvs_freelines(dlines); | |||
1895 | dlines = NULL((void *)0); | |||
1896 | } | |||
1897 | ||||
1898 | if (bnum != tnum) | |||
1899 | free(bnum); | |||
1900 | ||||
1901 | return (dlines); | |||
1902 | } | |||
1903 | ||||
1904 | void | |||
1905 | rcs_annotate_getlines(RCSFILE *rfp, RCSNUM *frev, struct rcs_line ***alines) | |||
1906 | { | |||
1907 | size_t plen; | |||
1908 | int i, nextroot; | |||
1909 | RCSNUM *bnum; | |||
1910 | struct rcs_branch *brp; | |||
1911 | struct rcs_delta *rdp, *trdp; | |||
1912 | u_char *patch; | |||
1913 | struct rcs_line *line; | |||
1914 | struct rcs_lines *dlines, *plines; | |||
1915 | ||||
1916 | rdp = trdp = NULL((void *)0); | |||
1917 | ||||
1918 | if (!RCSNUM_ISBRANCHREV(frev)(!((frev)->rn_len % 2) && ((frev)->rn_len >= 4))) | |||
1919 | fatal("rcs_annotate_getlines: branch revision expected"); | |||
1920 | ||||
1921 | /* revision on branch, get the branch root */ | |||
1922 | nextroot = 2; | |||
1923 | bnum = rcsnum_alloc(); | |||
1924 | rcsnum_cpy(frev, bnum, nextroot); | |||
1925 | ||||
1926 | /* | |||
1927 | * Going from HEAD to 1.1 enables the use of an array, which is | |||
1928 | * much faster. Unfortunately this is not possible with branch | |||
1929 | * revisions, so copy over our alines (array) into dlines (tailq). | |||
1930 | */ | |||
1931 | dlines = xcalloc(1, sizeof(*dlines)); | |||
1932 | TAILQ_INIT(&(dlines->l_lines))do { (&(dlines->l_lines))->tqh_first = ((void *)0); (&(dlines->l_lines))->tqh_last = &(&(dlines ->l_lines))->tqh_first; } while (0); | |||
1933 | line = xcalloc(1, sizeof(*line)); | |||
1934 | TAILQ_INSERT_TAIL(&(dlines->l_lines), line, l_list)do { (line)->l_list.tqe_next = ((void *)0); (line)->l_list .tqe_prev = (&(dlines->l_lines))->tqh_last; *(& (dlines->l_lines))->tqh_last = (line); (&(dlines-> l_lines))->tqh_last = &(line)->l_list.tqe_next; } while (0); | |||
1935 | ||||
1936 | for (i = 0; (*alines)[i] != NULL((void *)0); i++) { | |||
1937 | line = (*alines)[i]; | |||
1938 | line->l_lineno = i + 1; | |||
1939 | TAILQ_INSERT_TAIL(&(dlines->l_lines), line, l_list)do { (line)->l_list.tqe_next = ((void *)0); (line)->l_list .tqe_prev = (&(dlines->l_lines))->tqh_last; *(& (dlines->l_lines))->tqh_last = (line); (&(dlines-> l_lines))->tqh_last = &(line)->l_list.tqe_next; } while (0); | |||
1940 | } | |||
1941 | ||||
1942 | rdp = rcs_findrev(rfp, bnum); | |||
1943 | if (rdp == NULL((void *)0)) | |||
1944 | fatal("failed to grab branch root revision"); | |||
1945 | ||||
1946 | do { | |||
1947 | nextroot += 2; | |||
1948 | rcsnum_cpy(frev, bnum, nextroot); | |||
1949 | ||||
1950 | TAILQ_FOREACH(brp, &(rdp->rd_branches), rb_list)for((brp) = ((&(rdp->rd_branches))->tqh_first); (brp ) != ((void *)0); (brp) = ((brp)->rb_list.tqe_next)) { | |||
1951 | for (i = 0; i < nextroot - 1; i++) | |||
1952 | if (brp->rb_num->rn_id[i] != bnum->rn_id[i]) | |||
1953 | break; | |||
1954 | if (i == nextroot - 1) | |||
1955 | break; | |||
1956 | } | |||
1957 | ||||
1958 | if (brp == NULL((void *)0)) | |||
1959 | fatal("expected branch not found on branch list"); | |||
1960 | ||||
1961 | if ((rdp = rcs_findrev(rfp, brp->rb_num)) == NULL((void *)0)) | |||
1962 | fatal("failed to get delta for target rev"); | |||
1963 | ||||
1964 | for (;;) { | |||
1965 | if (rdp->rd_next->rn_len != 0) { | |||
1966 | trdp = rcs_findrev(rfp, rdp->rd_next); | |||
1967 | if (trdp == NULL((void *)0)) | |||
1968 | fatal("failed to grab next revision"); | |||
1969 | } | |||
1970 | ||||
1971 | if (rdp->rd_tlen == 0) { | |||
1972 | if (rcsparse_deltatexts(rfp, rdp->rd_num)) | |||
1973 | fatal("rcs_annotate_getlines: " | |||
1974 | "rcsparse_deltatexts"); | |||
1975 | if (rdp->rd_tlen == 0) { | |||
1976 | if (!rcsnum_differ(rdp->rd_num, bnum)) | |||
1977 | break; | |||
1978 | rdp = trdp; | |||
1979 | continue; | |||
1980 | } | |||
1981 | } | |||
1982 | ||||
1983 | plen = rdp->rd_tlen; | |||
1984 | patch = rdp->rd_text; | |||
1985 | plines = cvs_splitlines(patch, plen); | |||
1986 | rcs_patch_lines(dlines, plines, NULL((void *)0), rdp); | |||
1987 | cvs_freelines(plines); | |||
1988 | ||||
1989 | if (!rcsnum_differ(rdp->rd_num, bnum)) | |||
1990 | break; | |||
1991 | ||||
1992 | rdp = trdp; | |||
1993 | } | |||
1994 | } while (rcsnum_differ(rdp->rd_num, frev)); | |||
1995 | ||||
1996 | if (bnum != frev) | |||
1997 | free(bnum); | |||
1998 | ||||
1999 | /* | |||
2000 | * All lines have been parsed, now they must be copied over | |||
2001 | * into alines (array) again. | |||
2002 | */ | |||
2003 | free(*alines); | |||
2004 | ||||
2005 | i = 0; | |||
2006 | TAILQ_FOREACH(line, &(dlines->l_lines), l_list)for((line) = ((&(dlines->l_lines))->tqh_first); (line ) != ((void *)0); (line) = ((line)->l_list.tqe_next)) { | |||
2007 | if (line->l_line != NULL((void *)0)) | |||
2008 | i++; | |||
2009 | } | |||
2010 | *alines = xcalloc(i + 1, sizeof(struct rcs_line *)); | |||
2011 | (*alines)[i] = NULL((void *)0); | |||
2012 | ||||
2013 | i = 0; | |||
2014 | TAILQ_FOREACH(line, &(dlines->l_lines), l_list)for((line) = ((&(dlines->l_lines))->tqh_first); (line ) != ((void *)0); (line) = ((line)->l_list.tqe_next)) { | |||
2015 | if (line->l_line != NULL((void *)0)) | |||
2016 | (*alines)[i++] = line; | |||
2017 | } | |||
2018 | } | |||
2019 | ||||
2020 | /* | |||
2021 | * rcs_rev_getbuf() | |||
2022 | * | |||
2023 | * XXX: This is really really slow and should be avoided if at all possible! | |||
2024 | * | |||
2025 | * Get the entire contents of revision <rev> from the RCSFILE <rfp> and | |||
2026 | * return it as a BUF pointer. | |||
2027 | */ | |||
2028 | BUF * | |||
2029 | rcs_rev_getbuf(RCSFILE *rfp, RCSNUM *rev, int mode) | |||
2030 | { | |||
2031 | int expmode, expand; | |||
2032 | struct rcs_delta *rdp; | |||
2033 | struct rcs_lines *lines; | |||
2034 | struct rcs_line *lp, *nlp; | |||
2035 | BUF *bp; | |||
2036 | ||||
2037 | rdp = NULL((void *)0); | |||
2038 | expmode = RCS_KWEXP_NONE0x01; | |||
2039 | expand = 0; | |||
2040 | lines = rcs_rev_getlines(rfp, rev, NULL((void *)0)); | |||
| ||||
2041 | bp = buf_alloc(1024 * 16); | |||
2042 | ||||
2043 | if (!(mode & RCS_KWEXP_NONE0x01)) { | |||
2044 | expmode = rcs_kwexp_get(rfp); | |||
2045 | ||||
2046 | if (!(expmode & RCS_KWEXP_NONE0x01)) { | |||
2047 | if ((rdp = rcs_findrev(rfp, rev)) == NULL((void *)0)) { | |||
2048 | char version[RCSNUM_MAXSTR64]; | |||
2049 | ||||
2050 | rcsnum_tostr(rev, version, sizeof(version)); | |||
2051 | fatal("could not find desired version %s in %s", | |||
2052 | version, rfp->rf_path); | |||
2053 | } | |||
2054 | ||||
2055 | expand = 1; | |||
2056 | } | |||
2057 | } | |||
2058 | ||||
2059 | for (lp = TAILQ_FIRST(&lines->l_lines)((&lines->l_lines)->tqh_first); lp != NULL((void *)0);) { | |||
2060 | nlp = TAILQ_NEXT(lp, l_list)((lp)->l_list.tqe_next); | |||
2061 | ||||
2062 | if (lp->l_line == NULL((void *)0)) { | |||
2063 | lp = nlp; | |||
2064 | continue; | |||
2065 | } | |||
2066 | ||||
2067 | if (expand) | |||
2068 | rcs_kwexp_line(rfp->rf_path, rdp, lines, lp, expmode); | |||
2069 | ||||
2070 | do { | |||
2071 | buf_append(bp, lp->l_line, lp->l_len); | |||
2072 | } while ((lp = TAILQ_NEXT(lp, l_list)((lp)->l_list.tqe_next)) != nlp); | |||
2073 | } | |||
2074 | ||||
2075 | cvs_freelines(lines); | |||
2076 | ||||
2077 | return (bp); | |||
2078 | } | |||
2079 | ||||
2080 | /* | |||
2081 | * rcs_rev_write_fd() | |||
2082 | * | |||
2083 | * Write the entire contents of revision <frev> from the rcsfile <rfp> to | |||
2084 | * file descriptor <fd>. | |||
2085 | */ | |||
2086 | void | |||
2087 | rcs_rev_write_fd(RCSFILE *rfp, RCSNUM *rev, int _fd, int mode) | |||
2088 | { | |||
2089 | int fd; | |||
2090 | FILE *fp; | |||
2091 | size_t ret; | |||
2092 | int expmode, expand; | |||
2093 | struct rcs_delta *rdp; | |||
2094 | struct rcs_lines *lines; | |||
2095 | struct rcs_line *lp, *nlp; | |||
2096 | extern int print_stdout; | |||
2097 | ||||
2098 | rdp = NULL((void *)0); | |||
2099 | expmode = RCS_KWEXP_NONE0x01; | |||
2100 | expand = 0; | |||
2101 | lines = rcs_rev_getlines(rfp, rev, NULL((void *)0)); | |||
2102 | ||||
2103 | if (!(mode & RCS_KWEXP_NONE0x01)) { | |||
2104 | expmode = rcs_kwexp_get(rfp); | |||
2105 | ||||
2106 | if (!(expmode & RCS_KWEXP_NONE0x01)) { | |||
2107 | if ((rdp = rcs_findrev(rfp, rev)) == NULL((void *)0)) | |||
2108 | fatal("could not fetch revision"); | |||
2109 | expand = 1; | |||
2110 | } | |||
2111 | } | |||
2112 | ||||
2113 | fd = dup(_fd); | |||
2114 | if (fd == -1) | |||
2115 | fatal("rcs_rev_write_fd: dup: %s", strerror(errno(*__errno()))); | |||
2116 | ||||
2117 | if ((fp = fdopen(fd, "w")) == NULL((void *)0)) | |||
2118 | fatal("rcs_rev_write_fd: fdopen: %s", strerror(errno(*__errno()))); | |||
2119 | ||||
2120 | for (lp = TAILQ_FIRST(&lines->l_lines)((&lines->l_lines)->tqh_first); lp != NULL((void *)0);) { | |||
2121 | nlp = TAILQ_NEXT(lp, l_list)((lp)->l_list.tqe_next); | |||
2122 | ||||
2123 | if (lp->l_line == NULL((void *)0)) { | |||
2124 | lp = nlp; | |||
2125 | continue; | |||
2126 | } | |||
2127 | ||||
2128 | if (expand) | |||
2129 | rcs_kwexp_line(rfp->rf_path, rdp, lines, lp, expmode); | |||
2130 | ||||
2131 | do { | |||
2132 | /* | |||
2133 | * Solely for the checkout and update -p options. | |||
2134 | */ | |||
2135 | if (cvs_server_active == 1 && | |||
2136 | (cvs_cmdop == CVS_OP_CHECKOUT4 || | |||
2137 | cvs_cmdop == CVS_OP_UPDATE24) && print_stdout == 1) { | |||
2138 | ret = fwrite("M ", 1, 2, fp); | |||
2139 | if (ret != 2) | |||
2140 | fatal("rcs_rev_write_fd: %s", | |||
2141 | strerror(errno(*__errno()))); | |||
2142 | } | |||
2143 | ||||
2144 | ret = fwrite(lp->l_line, 1, lp->l_len, fp); | |||
2145 | if (ret != lp->l_len) | |||
2146 | fatal("rcs_rev_write_fd: %s", strerror(errno(*__errno()))); | |||
2147 | } while ((lp = TAILQ_NEXT(lp, l_list)((lp)->l_list.tqe_next)) != nlp); | |||
2148 | } | |||
2149 | ||||
2150 | cvs_freelines(lines); | |||
2151 | (void)fclose(fp); | |||
2152 | } | |||
2153 | ||||
2154 | /* | |||
2155 | * rcs_rev_write_stmp() | |||
2156 | * | |||
2157 | * Write the contents of the rev <rev> to a temporary file whose path is | |||
2158 | * specified using <template> (see mkstemp(3)). NB. This function will modify | |||
2159 | * <template>, as per mkstemp. | |||
2160 | */ | |||
2161 | int | |||
2162 | rcs_rev_write_stmp(RCSFILE *rfp, RCSNUM *rev, char *template, int mode) | |||
2163 | { | |||
2164 | int fd; | |||
2165 | ||||
2166 | if ((fd = mkstemp(template)) == -1) | |||
2167 | fatal("mkstemp: `%s': %s", template, strerror(errno(*__errno()))); | |||
2168 | ||||
2169 | worklist_add(template, &temp_files); | |||
2170 | rcs_rev_write_fd(rfp, rev, fd, mode); | |||
2171 | ||||
2172 | if (lseek(fd, 0, SEEK_SET0) == -1) | |||
2173 | fatal("rcs_rev_write_stmp: lseek: %s", strerror(errno(*__errno()))); | |||
2174 | ||||
2175 | return (fd); | |||
2176 | } | |||
2177 | ||||
2178 | static void | |||
2179 | rcs_kwexp_line(char *rcsfile, struct rcs_delta *rdp, struct rcs_lines *lines, | |||
2180 | struct rcs_line *line, int mode) | |||
2181 | { | |||
2182 | BUF *tmpbuf; | |||
2183 | int kwtype; | |||
2184 | u_int j, found; | |||
2185 | const u_char *c, *start, *fin, *end; | |||
2186 | char *kwstr, *rcsfile_basename; | |||
2187 | char expbuf[256], buf[256], path[PATH_MAX1024]; | |||
2188 | size_t clen, kwlen, len, tlen; | |||
2189 | ||||
2190 | kwtype = 0; | |||
2191 | kwstr = NULL((void *)0); | |||
2192 | ||||
2193 | if (mode & RCS_KWEXP_OLD0x10) | |||
2194 | return; | |||
2195 | ||||
2196 | len = line->l_len; | |||
2197 | if (len == 0) | |||
2198 | return; | |||
2199 | ||||
2200 | c = line->l_line; | |||
2201 | found = 0; | |||
2202 | /* Final character in buffer. */ | |||
2203 | fin = c + len - 1; | |||
2204 | ||||
2205 | if (strlcpy(path, rcsfile, sizeof(path)) >= sizeof(path)) | |||
2206 | fatal("rcs_kwexp_line: truncation"); | |||
2207 | rcsfile_basename = basename(path); | |||
2208 | ||||
2209 | /* | |||
2210 | * Keyword formats: | |||
2211 | * $Keyword$ | |||
2212 | * $Keyword: value$ | |||
2213 | */ | |||
2214 | for (; c < fin; c++) { | |||
2215 | if (*c != '$') | |||
2216 | continue; | |||
2217 | ||||
2218 | /* remember start of this possible keyword */ | |||
2219 | start = c; | |||
2220 | ||||
2221 | /* first following character has to be alphanumeric */ | |||
2222 | c++; | |||
2223 | if (!isalpha(*c)) { | |||
2224 | c = start; | |||
2225 | continue; | |||
2226 | } | |||
2227 | ||||
2228 | /* Number of characters between c and fin, inclusive. */ | |||
2229 | clen = fin - c + 1; | |||
2230 | ||||
2231 | /* look for any matching keywords */ | |||
2232 | found = 0; | |||
2233 | for (j = 0; j < RCS_NKWORDS(sizeof(rcs_expkw)/sizeof(rcs_expkw[0])); j++) { | |||
2234 | kwlen = strlen(rcs_expkw[j].kw_str); | |||
2235 | /* | |||
2236 | * kwlen must be less than clen since clen | |||
2237 | * includes either a terminating `$' or a `:'. | |||
2238 | */ | |||
2239 | if (kwlen < clen && | |||
2240 | memcmp(c, rcs_expkw[j].kw_str, kwlen) == 0 && | |||
2241 | (c[kwlen] == '$' || c[kwlen] == ':')) { | |||
2242 | found = 1; | |||
2243 | kwstr = rcs_expkw[j].kw_str; | |||
2244 | kwtype = rcs_expkw[j].kw_type; | |||
2245 | c += kwlen; | |||
2246 | break; | |||
2247 | } | |||
2248 | } | |||
2249 | ||||
2250 | if (found == 0 && cvs_tagname != NULL((void *)0)) { | |||
2251 | kwlen = strlen(cvs_tagname); | |||
2252 | if (kwlen < clen && | |||
2253 | memcmp(c, cvs_tagname, kwlen) == 0 && | |||
2254 | (c[kwlen] == '$' || c[kwlen] == ':')) { | |||
2255 | found = 1; | |||
2256 | kwstr = cvs_tagname; | |||
2257 | kwtype = RCS_KW_ID(0x0100 | 0x0200 | 0x2000 | 0x1000 | 0x0800); | |||
2258 | c += kwlen; | |||
2259 | } | |||
2260 | } | |||
2261 | ||||
2262 | /* unknown keyword, continue looking */ | |||
2263 | if (found == 0) { | |||
2264 | c = start; | |||
2265 | continue; | |||
2266 | } | |||
2267 | ||||
2268 | /* | |||
2269 | * if the next character was ':' we need to look for | |||
2270 | * an '$' before the end of the line to be sure it is | |||
2271 | * in fact a keyword. | |||
2272 | */ | |||
2273 | if (*c == ':') { | |||
2274 | for (; c <= fin; ++c) { | |||
2275 | if (*c == '$' || *c == '\n') | |||
2276 | break; | |||
2277 | } | |||
2278 | ||||
2279 | if (*c != '$') { | |||
2280 | c = start; | |||
2281 | continue; | |||
2282 | } | |||
2283 | } | |||
2284 | end = c + 1; | |||
2285 | ||||
2286 | /* start constructing the expansion */ | |||
2287 | expbuf[0] = '\0'; | |||
2288 | ||||
2289 | if (mode & RCS_KWEXP_NAME0x02) { | |||
2290 | if (strlcat(expbuf, "$", sizeof(expbuf)) >= | |||
2291 | sizeof(expbuf) || strlcat(expbuf, kwstr, | |||
2292 | sizeof(expbuf)) >= sizeof(expbuf)) | |||
2293 | fatal("rcs_kwexp_line: truncated"); | |||
2294 | if ((mode & RCS_KWEXP_VAL0x04) && | |||
2295 | strlcat(expbuf, ": ", sizeof(expbuf)) >= | |||
2296 | sizeof(expbuf)) | |||
2297 | fatal("rcs_kwexp_line: truncated"); | |||
2298 | } | |||
2299 | ||||
2300 | /* | |||
2301 | * order matters because of RCS_KW_ID and | |||
2302 | * RCS_KW_HEADER here | |||
2303 | */ | |||
2304 | if (mode & RCS_KWEXP_VAL0x04) { | |||
2305 | if (kwtype & RCS_KW_RCSFILE0x0100) { | |||
2306 | if (!(kwtype & RCS_KW_FULLPATH0x0010)) | |||
2307 | (void)strlcat(expbuf, rcsfile_basename, | |||
2308 | sizeof(expbuf)); | |||
2309 | else | |||
2310 | (void)strlcat(expbuf, rcsfile, | |||
2311 | sizeof(expbuf)); | |||
2312 | if (strlcat(expbuf, " ", sizeof(expbuf)) >= | |||
2313 | sizeof(expbuf)) | |||
2314 | fatal("rcs_kwexp_line: truncated"); | |||
2315 | } | |||
2316 | ||||
2317 | if (kwtype & RCS_KW_REVISION0x0200) { | |||
2318 | rcsnum_tostr(rdp->rd_num, buf, sizeof(buf)); | |||
2319 | if (strlcat(buf, " ", sizeof(buf)) >= | |||
2320 | sizeof(buf) || strlcat(expbuf, buf, | |||
2321 | sizeof(expbuf)) >= sizeof(buf)) | |||
2322 | fatal("rcs_kwexp_line: truncated"); | |||
2323 | } | |||
2324 | ||||
2325 | if (kwtype & RCS_KW_DATE0x2000) { | |||
2326 | if (strftime(buf, sizeof(buf), | |||
2327 | "%Y/%m/%d %H:%M:%S ", | |||
2328 | &rdp->rd_date) == 0) | |||
2329 | fatal("rcs_kwexp_line: strftime " | |||
2330 | "failure"); | |||
2331 | if (strlcat(expbuf, buf, sizeof(expbuf)) >= | |||
2332 | sizeof(expbuf)) | |||
2333 | fatal("rcs_kwexp_line: string " | |||
2334 | "truncated"); | |||
2335 | } | |||
2336 | ||||
2337 | if (kwtype & RCS_KW_MDOCDATE0x0020) { | |||
2338 | /* | |||
2339 | * Do not prepend ' ' for a single | |||
2340 | * digit, %e would do so and there is | |||
2341 | * no better format for strftime(). | |||
2342 | */ | |||
2343 | if (strftime(buf, sizeof(buf), | |||
2344 | (rdp->rd_date.tm_mday < 10) ? | |||
2345 | "%B%e %Y " : "%B %e %Y ", | |||
2346 | &rdp->rd_date) == 0) | |||
2347 | fatal("rcs_kwexp_line: strftime " | |||
2348 | "failure"); | |||
2349 | if (strlcat(expbuf, buf, sizeof(expbuf)) >= | |||
2350 | sizeof(expbuf)) | |||
2351 | fatal("rcs_kwexp_line: string " | |||
2352 | "truncated"); | |||
2353 | } | |||
2354 | ||||
2355 | if (kwtype & RCS_KW_AUTHOR0x1000) { | |||
2356 | if (strlcat(expbuf, rdp->rd_author, | |||
2357 | sizeof(expbuf)) >= sizeof(expbuf) || | |||
2358 | strlcat(expbuf, " ", sizeof(expbuf)) >= | |||
2359 | sizeof(expbuf)) | |||
2360 | fatal("rcs_kwexp_line: string " | |||
2361 | "truncated"); | |||
2362 | } | |||
2363 | ||||
2364 | if (kwtype & RCS_KW_STATE0x0800) { | |||
2365 | if (strlcat(expbuf, rdp->rd_state, | |||
2366 | sizeof(expbuf)) >= sizeof(expbuf) || | |||
2367 | strlcat(expbuf, " ", sizeof(expbuf)) >= | |||
2368 | sizeof(expbuf)) | |||
2369 | fatal("rcs_kwexp_line: string " | |||
2370 | "truncated"); | |||
2371 | } | |||
2372 | ||||
2373 | /* order does not matter anymore below */ | |||
2374 | if (kwtype & RCS_KW_LOG0x4000) { | |||
2375 | char linebuf[256]; | |||
2376 | struct rcs_line *cur, *lp; | |||
2377 | char *logp, *l_line, *prefix, *q, *sprefix; | |||
2378 | size_t i; | |||
2379 | ||||
2380 | /* Log line */ | |||
2381 | if (!(kwtype & RCS_KW_FULLPATH0x0010)) | |||
2382 | (void)strlcat(expbuf, | |||
2383 | rcsfile_basename, sizeof(expbuf)); | |||
2384 | else | |||
2385 | (void)strlcat(expbuf, rcsfile, | |||
2386 | sizeof(expbuf)); | |||
2387 | ||||
2388 | if (strlcat(expbuf, " ", sizeof(expbuf)) >= | |||
2389 | sizeof(expbuf)) | |||
2390 | fatal("rcs_kwexp_line: string " | |||
2391 | "truncated"); | |||
2392 | ||||
2393 | cur = line; | |||
2394 | ||||
2395 | /* copy rdp->rd_log for strsep */ | |||
2396 | logp = xstrdup(rdp->rd_log); | |||
2397 | ||||
2398 | /* copy our prefix for later processing */ | |||
2399 | prefix = xmalloc(start - line->l_line + 1); | |||
2400 | memcpy(prefix, line->l_line, | |||
2401 | start - line->l_line); | |||
2402 | prefix[start - line->l_line] = '\0'; | |||
2403 | ||||
2404 | /* copy also prefix without trailing blanks. */ | |||
2405 | sprefix = xstrdup(prefix); | |||
2406 | for (i = strlen(sprefix); i > 0 && | |||
2407 | sprefix[i - 1] == ' '; i--) | |||
2408 | sprefix[i - 1] = '\0'; | |||
2409 | ||||
2410 | /* new line: revision + date + author */ | |||
2411 | linebuf[0] = '\0'; | |||
2412 | if (strlcat(linebuf, "Revision ", | |||
2413 | sizeof(linebuf)) >= sizeof(linebuf)) | |||
2414 | fatal("rcs_kwexp_line: truncated"); | |||
2415 | rcsnum_tostr(rdp->rd_num, buf, sizeof(buf)); | |||
2416 | if (strlcat(linebuf, buf, sizeof(linebuf)) | |||
2417 | >= sizeof(buf)) | |||
2418 | fatal("rcs_kwexp_line: truncated"); | |||
2419 | if (strftime(buf, sizeof(buf), | |||
2420 | " %Y/%m/%d %H:%M:%S ", | |||
2421 | &rdp->rd_date) == 0) | |||
2422 | fatal("rcs_kwexp_line: strftime " | |||
2423 | "failure"); | |||
2424 | if (strlcat(linebuf, buf, sizeof(linebuf)) | |||
2425 | >= sizeof(linebuf)) | |||
2426 | fatal("rcs_kwexp_line: string " | |||
2427 | "truncated"); | |||
2428 | if (strlcat(linebuf, rdp->rd_author, | |||
2429 | sizeof(linebuf)) >= sizeof(linebuf)) | |||
2430 | fatal("rcs_kwexp_line: string " | |||
2431 | "truncated"); | |||
2432 | ||||
2433 | lp = xcalloc(1, sizeof(*lp)); | |||
2434 | xasprintf((char **)&(lp->l_line), "%s%s\n", | |||
2435 | prefix, linebuf); | |||
2436 | lp->l_len = strlen(lp->l_line); | |||
2437 | TAILQ_INSERT_AFTER(&(lines->l_lines), cur, lp,do { if (((lp)->l_list.tqe_next = (cur)->l_list.tqe_next ) != ((void *)0)) (lp)->l_list.tqe_next->l_list.tqe_prev = &(lp)->l_list.tqe_next; else (&(lines->l_lines ))->tqh_last = &(lp)->l_list.tqe_next; (cur)->l_list .tqe_next = (lp); (lp)->l_list.tqe_prev = &(cur)->l_list .tqe_next; } while (0) | |||
2438 | l_list)do { if (((lp)->l_list.tqe_next = (cur)->l_list.tqe_next ) != ((void *)0)) (lp)->l_list.tqe_next->l_list.tqe_prev = &(lp)->l_list.tqe_next; else (&(lines->l_lines ))->tqh_last = &(lp)->l_list.tqe_next; (cur)->l_list .tqe_next = (lp); (lp)->l_list.tqe_prev = &(cur)->l_list .tqe_next; } while (0); | |||
2439 | cur = lp; | |||
2440 | ||||
2441 | /* Log message */ | |||
2442 | q = logp; | |||
2443 | while ((l_line = strsep(&q, "\n")) != NULL((void *)0) && | |||
2444 | q != NULL((void *)0)) { | |||
2445 | lp = xcalloc(1, sizeof(*lp)); | |||
2446 | ||||
2447 | if (l_line[0] == '\0') { | |||
2448 | xasprintf((char **)&(lp->l_line), | |||
2449 | "%s\n", sprefix); | |||
2450 | } else { | |||
2451 | xasprintf((char **)&(lp->l_line), | |||
2452 | "%s%s\n", prefix, l_line); | |||
2453 | } | |||
2454 | ||||
2455 | lp->l_len = strlen(lp->l_line); | |||
2456 | TAILQ_INSERT_AFTER(&(lines->l_lines),do { if (((lp)->l_list.tqe_next = (cur)->l_list.tqe_next ) != ((void *)0)) (lp)->l_list.tqe_next->l_list.tqe_prev = &(lp)->l_list.tqe_next; else (&(lines->l_lines ))->tqh_last = &(lp)->l_list.tqe_next; (cur)->l_list .tqe_next = (lp); (lp)->l_list.tqe_prev = &(cur)->l_list .tqe_next; } while (0) | |||
2457 | cur, lp, l_list)do { if (((lp)->l_list.tqe_next = (cur)->l_list.tqe_next ) != ((void *)0)) (lp)->l_list.tqe_next->l_list.tqe_prev = &(lp)->l_list.tqe_next; else (&(lines->l_lines ))->tqh_last = &(lp)->l_list.tqe_next; (cur)->l_list .tqe_next = (lp); (lp)->l_list.tqe_prev = &(cur)->l_list .tqe_next; } while (0); | |||
2458 | cur = lp; | |||
2459 | } | |||
2460 | free(logp); | |||
2461 | ||||
2462 | /* | |||
2463 | * This is just another hairy mess, but it must | |||
2464 | * be done: All characters behind Log will be | |||
2465 | * written in a new line next to log messages. | |||
2466 | * But that's not enough, we have to strip all | |||
2467 | * trailing whitespaces of our prefix. | |||
2468 | */ | |||
2469 | lp = xcalloc(1, sizeof(*lp)); | |||
2470 | xasprintf((char **)&lp->l_line, "%s%s", | |||
2471 | sprefix, end); | |||
2472 | lp->l_len = strlen(lp->l_line); | |||
2473 | TAILQ_INSERT_AFTER(&(lines->l_lines), cur, lp,do { if (((lp)->l_list.tqe_next = (cur)->l_list.tqe_next ) != ((void *)0)) (lp)->l_list.tqe_next->l_list.tqe_prev = &(lp)->l_list.tqe_next; else (&(lines->l_lines ))->tqh_last = &(lp)->l_list.tqe_next; (cur)->l_list .tqe_next = (lp); (lp)->l_list.tqe_prev = &(cur)->l_list .tqe_next; } while (0) | |||
2474 | l_list)do { if (((lp)->l_list.tqe_next = (cur)->l_list.tqe_next ) != ((void *)0)) (lp)->l_list.tqe_next->l_list.tqe_prev = &(lp)->l_list.tqe_next; else (&(lines->l_lines ))->tqh_last = &(lp)->l_list.tqe_next; (cur)->l_list .tqe_next = (lp); (lp)->l_list.tqe_prev = &(cur)->l_list .tqe_next; } while (0); | |||
2475 | cur = lp; | |||
2476 | ||||
2477 | end = line->l_line + line->l_len - 1; | |||
2478 | ||||
2479 | free(prefix); | |||
2480 | free(sprefix); | |||
2481 | ||||
2482 | } | |||
2483 | ||||
2484 | if (kwtype & RCS_KW_SOURCE0x0400) { | |||
2485 | if (strlcat(expbuf, rcsfile, sizeof(expbuf)) >= | |||
2486 | sizeof(expbuf) || strlcat(expbuf, " ", | |||
2487 | sizeof(expbuf)) >= sizeof(expbuf)) | |||
2488 | fatal("rcs_kwexp_line: string " | |||
2489 | "truncated"); | |||
2490 | } | |||
2491 | ||||
2492 | if (kwtype & RCS_KW_NAME0x8000) | |||
2493 | if (strlcat(expbuf, " ", sizeof(expbuf)) >= | |||
2494 | sizeof(expbuf)) | |||
2495 | fatal("rcs_kwexp_line: string " | |||
2496 | "truncated"); | |||
2497 | ||||
2498 | if (kwtype & RCS_KW_LOCKER0x0040) | |||
2499 | if (strlcat(expbuf, " ", sizeof(expbuf)) >= | |||
2500 | sizeof(expbuf)) | |||
2501 | fatal("rcs_kwexp_line: string " | |||
2502 | "truncated"); | |||
2503 | } | |||
2504 | ||||
2505 | /* end the expansion */ | |||
2506 | if (mode & RCS_KWEXP_NAME0x02) | |||
2507 | if (strlcat(expbuf, "$", | |||
2508 | sizeof(expbuf)) >= sizeof(expbuf)) | |||
2509 | fatal("rcs_kwexp_line: truncated"); | |||
2510 | ||||
2511 | /* Concatenate everything together. */ | |||
2512 | tmpbuf = buf_alloc(len + strlen(expbuf)); | |||
2513 | /* Append everything before keyword. */ | |||
2514 | buf_append(tmpbuf, line->l_line, | |||
2515 | start - line->l_line); | |||
2516 | /* Append keyword. */ | |||
2517 | buf_puts(tmpbuf, expbuf); | |||
2518 | /* Point c to end of keyword. */ | |||
2519 | tlen = buf_len(tmpbuf) - 1; | |||
2520 | /* Append everything after keyword. */ | |||
2521 | buf_append(tmpbuf, end, | |||
2522 | line->l_line + line->l_len - end); | |||
2523 | c = buf_get(tmpbuf) + tlen; | |||
2524 | /* Point fin to end of data. */ | |||
2525 | fin = buf_get(tmpbuf) + buf_len(tmpbuf) - 1; | |||
2526 | /* Recalculate new length. */ | |||
2527 | len = buf_len(tmpbuf); | |||
2528 | ||||
2529 | /* tmpbuf is now ready, convert to string */ | |||
2530 | if (line->l_needsfree) | |||
2531 | free(line->l_line); | |||
2532 | line->l_len = len; | |||
2533 | line->l_line = buf_release(tmpbuf); | |||
2534 | line->l_needsfree = 1; | |||
2535 | } | |||
2536 | } | |||
2537 | ||||
2538 | /* rcs_translate_tag() */ | |||
2539 | RCSNUM * | |||
2540 | rcs_translate_tag(const char *revstr, RCSFILE *rfp) | |||
2541 | { | |||
2542 | int follow; | |||
2543 | time_t deltatime; | |||
2544 | char branch[CVS_REV_BUFSZ32]; | |||
2545 | RCSNUM *brev, *frev, *rev; | |||
2546 | struct rcs_delta *rdp, *trdp; | |||
2547 | time_t cdate; | |||
2548 | ||||
2549 | brev = frev = NULL((void *)0); | |||
2550 | ||||
2551 | if (revstr == NULL((void *)0)) { | |||
2552 | if (rfp->rf_branch != NULL((void *)0)) { | |||
2553 | rcsnum_tostr(rfp->rf_branch, branch, sizeof(branch)); | |||
2554 | revstr = branch; | |||
2555 | } else { | |||
2556 | revstr = RCS_HEAD_BRANCH"HEAD"; | |||
2557 | } | |||
2558 | } | |||
2559 | ||||
2560 | if ((rev = rcs_get_revision(revstr, rfp)) == NULL((void *)0)) | |||
2561 | return (NULL((void *)0)); | |||
2562 | ||||
2563 | if ((rdp = rcs_findrev(rfp, rev)) == NULL((void *)0)) | |||
2564 | return (NULL((void *)0)); | |||
2565 | ||||
2566 | /* let's see if we must follow a branch */ | |||
2567 | if (!strcmp(revstr, RCS_HEAD_BRANCH"HEAD")) | |||
2568 | follow = 1; | |||
2569 | else { | |||
2570 | frev = rcs_sym_getrev(rfp, revstr); | |||
2571 | if (frev == NULL((void *)0)) | |||
2572 | frev = rcsnum_parse(revstr); | |||
2573 | ||||
2574 | brev = rcsnum_alloc(); | |||
2575 | rcsnum_cpy(rev, brev, rev->rn_len - 1); | |||
2576 | ||||
2577 | if (frev != NULL((void *)0) && RCSNUM_ISBRANCH(frev)((frev)->rn_len % 2) && | |||
2578 | !rcsnum_cmp(frev, brev, 0)) { | |||
2579 | follow = 1; | |||
2580 | } else | |||
2581 | follow = 0; | |||
2582 | ||||
2583 | free(brev); | |||
2584 | } | |||
2585 | ||||
2586 | if (cvs_specified_date != -1) | |||
2587 | cdate = cvs_specified_date; | |||
2588 | else | |||
2589 | cdate = cvs_directory_date; | |||
2590 | ||||
2591 | if (cdate == -1) { | |||
2592 | free(frev); | |||
2593 | ||||
2594 | /* XXX */ | |||
2595 | if (rev->rn_len < 4 || !follow) { | |||
2596 | return (rev); | |||
2597 | } | |||
2598 | ||||
2599 | /* Find the latest delta on that branch */ | |||
2600 | free(rev); | |||
2601 | for (;;) { | |||
2602 | if (rdp->rd_next->rn_len == 0) | |||
2603 | break; | |||
2604 | if ((rdp = rcs_findrev(rfp, rdp->rd_next)) == NULL((void *)0)) | |||
2605 | fatal("rcs_translate_tag: could not fetch " | |||
2606 | "branch delta"); | |||
2607 | } | |||
2608 | ||||
2609 | rev = rcsnum_alloc(); | |||
2610 | rcsnum_cpy(rdp->rd_num, rev, 0); | |||
2611 | return (rev); | |||
2612 | } | |||
2613 | ||||
2614 | if (frev != NULL((void *)0)) { | |||
2615 | brev = rcsnum_revtobr(frev); | |||
2616 | brev->rn_len = rev->rn_len - 1; | |||
2617 | free(frev); | |||
2618 | } | |||
2619 | ||||
2620 | free(rev); | |||
2621 | ||||
2622 | do { | |||
2623 | deltatime = timegm(&(rdp->rd_date)); | |||
2624 | ||||
2625 | if (RCSNUM_ISBRANCHREV(rdp->rd_num)(!((rdp->rd_num)->rn_len % 2) && ((rdp->rd_num )->rn_len >= 4))) { | |||
2626 | if (deltatime > cdate) { | |||
2627 | trdp = TAILQ_PREV(rdp, rcs_dlist, rd_list)(*(((struct rcs_dlist *)((rdp)->rd_list.tqe_prev))->tqh_last )); | |||
2628 | if (trdp == NULL((void *)0)) | |||
2629 | trdp = rdp; | |||
2630 | ||||
2631 | if (trdp->rd_num->rn_len != rdp->rd_num->rn_len) | |||
2632 | return (NULL((void *)0)); | |||
2633 | ||||
2634 | rev = rcsnum_alloc(); | |||
2635 | rcsnum_cpy(trdp->rd_num, rev, 0); | |||
2636 | return (rev); | |||
2637 | } | |||
2638 | ||||
2639 | if (rdp->rd_next->rn_len == 0) { | |||
2640 | rev = rcsnum_alloc(); | |||
2641 | rcsnum_cpy(rdp->rd_num, rev, 0); | |||
2642 | return (rev); | |||
2643 | } | |||
2644 | } else { | |||
2645 | if (deltatime < cdate) { | |||
2646 | rev = rcsnum_alloc(); | |||
2647 | rcsnum_cpy(rdp->rd_num, rev, 0); | |||
2648 | return (rev); | |||
2649 | } | |||
2650 | } | |||
2651 | ||||
2652 | if (follow && rdp->rd_next->rn_len != 0) { | |||
2653 | if (brev != NULL((void *)0) && !rcsnum_cmp(brev, rdp->rd_num, 0)) | |||
2654 | break; | |||
2655 | ||||
2656 | trdp = rcs_findrev(rfp, rdp->rd_next); | |||
2657 | if (trdp == NULL((void *)0)) | |||
2658 | fatal("failed to grab next revision"); | |||
2659 | rdp = trdp; | |||
2660 | } else | |||
2661 | follow = 0; | |||
2662 | } while (follow); | |||
2663 | ||||
2664 | return (NULL((void *)0)); | |||
2665 | } |