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 }