[PATCH] git-cvs2git: create tags
[git] / cvs2git.c
1 /*
2  * cvs2git
3  *
4  * Copyright (C) Linus Torvalds 2005
5  */
6
7 #include <stdio.h>
8 #include <ctype.h>
9 #include <string.h>
10 #include <stdlib.h>
11 #include <unistd.h>
12
13 static int verbose = 0;
14
15 /*
16  * This is a really stupid program that takes cvsps output, and
17  * generates a a long _shell_script_ that will create the GIT archive
18  * from it. 
19  *
20  * You've been warned. I told you it was stupid.
21  *
22  * NOTE NOTE NOTE! In order to do branches correctly, this needs
23  * the fixed cvsps that has the "Ancestor branch" tag output.
24  * Hopefully David Mansfield will update his distribution soon
25  * enough (he's the one who wrote the patch, so at least we don't
26  * have to figt maintainer issues ;)
27  *
28  * Usage:
29  *
30  *      TZ=UTC cvsps -A |
31  *              cvs2git --cvsroot=[root] --module=[module] > script
32  *
33  * Creates a shell script that will generate the .git archive of
34  * the names CVS repository.
35  *
36  * IMPORTANT NOTE ABOUT "cvsps"! This requires version 2.1 or better,
37  * and the "TZ=UTC" and the "-A" flag is required for sane results!
38  */
39 enum state {
40         Header,
41         Log,
42         Members
43 };
44
45 static const char *cvsroot;
46 static const char *cvsmodule;
47
48 static char date[100];
49 static char author[100];
50 static char branch[100];
51 static char ancestor[100];
52 static char tag[100];
53 static char log[32768];
54 static int loglen = 0;
55 static int initial_commit = 1;
56
57 static void lookup_author(char *n, char **name, char **email)
58 {
59         /*
60          * FIXME!!! I'm lazy and stupid.
61          *
62          * This could be something like
63          *
64          *      printf("lookup_author '%s'\n", n);
65          *      *name = "$author_name";
66          *      *email = "$author_email";
67          *
68          * and that would allow the script to do its own
69          * lookups at run-time.
70          */
71         *name = n;
72         *email = n;
73 }
74
75 static void prepare_commit(void)
76 {
77         char *author_name, *author_email;
78         char *src_branch;
79
80         lookup_author(author, &author_name, &author_email);
81
82         printf("export GIT_COMMITTER_NAME=%s\n", author_name);
83         printf("export GIT_COMMITTER_EMAIL=%s\n", author_email);
84         printf("export GIT_COMMITTER_DATE='+0000 %s'\n", date);
85
86         printf("export GIT_AUTHOR_NAME=%s\n", author_name);
87         printf("export GIT_AUTHOR_EMAIL=%s\n", author_email);
88         printf("export GIT_AUTHOR_DATE='+0000 %s'\n", date);
89
90         if (initial_commit)
91                 return;
92
93         src_branch = *ancestor ? ancestor : branch;
94         if (!strcmp(src_branch, "HEAD"))
95                 src_branch = "master";
96         printf("ln -sf refs/heads/'%s' .git/HEAD\n", src_branch);
97
98         /*
99          * Even if cvsps claims an ancestor, we'll let the new
100          * branch name take precedence if it already exists
101          */
102         if (*ancestor) {
103                 src_branch = branch;
104                 if (!strcmp(src_branch, "HEAD"))
105                         src_branch = "master";
106                 printf("[ -e .git/refs/heads/'%s' ] && ln -sf refs/heads/'%s' .git/HEAD\n",
107                         src_branch, src_branch);
108         }
109
110         printf("git-read-tree -m HEAD || exit 1\n");
111         printf("git-checkout-cache -f -u -a\n");
112 }
113
114 static void commit(void)
115 {
116         const char *cmit_parent = initial_commit ? "" : "-p HEAD";
117         const char *dst_branch;
118         char *space;
119         int i;
120
121         printf("tree=$(git-write-tree)\n");
122         printf("cat > .cmitmsg <<EOFMSG\n");
123
124         /* Escape $ characters, and remove control characters */
125         for (i = 0; i < loglen; i++) {
126                 unsigned char c = log[i];
127
128                 switch (c) {
129                 case '$':
130                 case '\\':
131                 case '`':
132                         putchar('\\');
133                         break;
134                 case 0 ... 31:
135                         if (c == '\n' || c == '\t')
136                                 break;
137                 case 128 ... 159:
138                         continue;
139                 }
140                 putchar(c);
141         }
142         printf("\nEOFMSG\n");
143         printf("commit=$(cat .cmitmsg | git-commit-tree $tree %s)\n", cmit_parent);
144
145         dst_branch = branch;
146         if (!strcmp(dst_branch, "HEAD"))
147                 dst_branch = "master";
148
149         printf("echo $commit > .git/refs/heads/'%s'\n", dst_branch);
150
151         space = strchr(tag, ' ');
152         if (space)
153                 *space = 0;
154         if (strcmp(tag, "(none)"))
155                 printf("echo $commit > .git/refs/tags/'%s'\n", tag);
156
157         printf("echo 'Committed (to %s):' ; cat .cmitmsg; echo\n", dst_branch);
158
159         *date = 0;
160         *author = 0;
161         *branch = 0;
162         *ancestor = 0;
163         *tag = 0;
164         loglen = 0;
165
166         initial_commit = 0;
167 }
168
169 static void update_file(char *line)
170 {
171         char *name, *version;
172         char *dir;
173
174         while (isspace(*line))
175                 line++;
176         name = line;
177         line = strchr(line, ':');
178         if (!line)
179                 return;
180         *line++ = 0;
181         line = strchr(line, '>');
182         if (!line)
183                 return;
184         *line++ = 0;
185         version = line;
186         line = strchr(line, '(');
187         if (line) {     /* "(DEAD)" */
188                 printf("git-update-cache --force-remove '%s'\n", name);
189                 return;
190         }
191
192         dir = strrchr(name, '/');
193         if (dir)
194                 printf("mkdir -p %.*s\n", (int)(dir - name), name);
195
196         printf("cvs -q -d %s checkout -r%s -p '%s/%s' > '%s'\n", cvsroot, version, cvsmodule, name, name);
197         printf("git-update-cache --add -- '%s'\n", name);
198 }
199
200 struct hdrentry {
201         const char *name;
202         char *dest;
203 } hdrs[] = {
204         { "Date:", date },
205         { "Author:", author },
206         { "Branch:", branch },
207         { "Ancestor branch:", ancestor },
208         { "Tag:", tag },
209         { "Log:", NULL },
210         { NULL, NULL }
211 };
212
213 int main(int argc, char **argv)
214 {
215         static char line[1000];
216         enum state state = Header;
217         int i;
218
219         for (i = 1; i < argc; i++) {
220                 const char *arg = argv[i];
221                 if (!memcmp(arg, "--cvsroot=", 10)) {
222                         cvsroot = arg + 10;
223                         continue;
224                 }
225                 if (!memcmp(arg, "--module=", 9)) {
226                         cvsmodule = arg+9;
227                         continue;
228                 } 
229                 if (!strcmp(arg, "-v")) {
230                         verbose = 1;
231                         continue;
232                 }
233         }
234
235
236         if (!cvsroot)
237                 cvsroot = getenv("CVSROOT");
238
239         if (!cvsmodule || !cvsroot) {
240                 fprintf(stderr, "I need a CVSROOT and module name\n");
241                 exit(1);
242         }
243
244         printf("[ -d .git ] && exit 1\n");
245         printf("git-init-db\n");
246         printf("mkdir -p .git/refs/heads\n");
247         printf("mkdir -p .git/refs/tags\n");
248         printf("ln -sf refs/heads/master .git/HEAD\n");
249
250         while (fgets(line, sizeof(line), stdin) != NULL) {
251                 int linelen = strlen(line);
252
253                 while (linelen && isspace(line[linelen-1]))
254                         line[--linelen] = 0;
255
256                 switch (state) {
257                 struct hdrentry *entry;
258
259                 case Header:
260                         if (verbose)
261                                 printf("# H: %s\n", line);
262                         for (entry = hdrs ; entry->name ; entry++) {
263                                 int len = strlen(entry->name);
264                                 char *val;
265
266                                 if (memcmp(entry->name, line, len))
267                                         continue;
268                                 if (!entry->dest) {
269                                         state = Log;
270                                         break;
271                                 }
272                                 val = line + len;
273                                 linelen -= len;
274                                 while (isspace(*val)) {
275                                         val++;
276                                         linelen--;
277                                 }
278                                 memcpy(entry->dest, val, linelen+1);
279                                 break;
280                         }
281                         continue;
282
283                 case Log:
284                         if (verbose)
285                                 printf("# L: %s\n", line);
286                         if (!strcmp(line, "Members:")) {
287                                 while (loglen && isspace(log[loglen-1]))
288                                         log[--loglen] = 0;
289                                 prepare_commit();
290                                 state = Members;
291                                 continue;
292                         }
293                                 
294                         if (loglen + linelen + 5 > sizeof(log))
295                                 continue;
296                         memcpy(log + loglen, line, linelen);
297                         loglen += linelen;
298                         log[loglen++] = '\n';
299                         continue;
300
301                 case Members:
302                         if (verbose)
303                                 printf("# M: %s\n", line);
304                         if (!linelen) {
305                                 commit();
306                                 state = Header;
307                                 continue;
308                         }
309                         update_file(line);
310                         continue;
311                 }
312         }
313         return 0;
314 }