Fossil

  int rev;                    /* SVN revision number */
  int parent;                 /* SVN revision number of parent check-in */
  char *zBranch;              /* Name of a branch for a commit */
  char *zDate;                /* Date/time stamp */
  char *zUser;                /* User name */
  char *zComment;             /* Comment of a commit */
  int flatFlag;               /* True if whole repo is a single file tree */
  const char *zTrunk;         /* Name of trunk folder in repo root */
  int lenTrunk;               /* String length of zTrunk */
  const char *zBranches;      /* Name of branches folder in repo root */
  int lenBranches;            /* String length of zBranches */
  const char *zTags;          /* Name of tags folder in repo root */
  int lenTags;                /* String length of zTags */
  Blob filter;                /* Path to repo root */
} gsvn;
typedef struct {
  const char *zKey;
  const char *zVal;
} KeyVal;
typedef struct {
  KeyVal *aHeaders;

static void svn_create_manifest(
){
  Blob manifest;
  static Stmt insRev;
  static Stmt qParent;
  static Stmt qFiles;
  static Stmt qTags;
  char zFilter[200];
  int nBaseFilter;
  int nFilter;
  int rid;
  const char *zParentBranch = 0;
  Blob mcksum;

  db_static_prepare(&insRev, "REPLACE INTO xrevisions (trev, tbranch, tuuid) "
                             "VALUES(:rev, :branch, "
                             " (SELECT uuid FROM blob WHERE rid=:rid))");
  db_static_prepare(&qParent, "SELECT tuuid, tbranch FROM xrevisions "
                              "WHERE trev=:rev");
  db_static_prepare(&qFiles, "SELECT tpath, trid, tperm FROM xfiles "
                             "WHERE tpath GLOB :filter ORDER BY tpath");
  db_static_prepare(&qTags, "SELECT ttag FROM xtags WHERE trev=:rev");
  if( db_int(0, "SELECT 1 FROM xfiles LIMIT 1")==0 ){ return; }
  if( !gsvn.flatFlag ){
    if( gsvn.zBranch==0 || gsvn.zBranch[0]=='\0' ){ return; }
    if( gsvn.parent<0 ){
      gsvn.parent = db_int(-1, "SELECT ifnull(max(trev),-1) FROM xrevisions "
                               "WHERE tbranch=%Q", gsvn.zBranch);
    }
    db_bind_int(&insRev, ":rev", gsvn.rev);
    db_bind_text(&insRev, ":branch", gsvn.zBranch);
    db_bind_int(&insRev, ":rid", 0);

  blob_zero(&manifest);
  if( gsvn.zComment ){
    blob_appendf(&manifest, "C %F\n", gsvn.zComment);
  }else{
    blob_append(&manifest, "C (no\\scomment)\n", 16);
  }
  blob_appendf(&manifest, "D %s\n", gsvn.zDate);
  nBaseFilter = blob_size(&gsvn.filter);
  if( strncmp(gsvn.zBranch, "trunk", 5)==0 ){
    memcpy(zFilter, "trunk/*", 8);
  if( strcmp(gsvn.zBranch, gsvn.zTrunk)==0 ){
    blob_appendf(&gsvn.filter, "%s*", gsvn.zTrunk);
    nFilter = 6;
  }else{
    sqlite3_snprintf(sizeof(zFilter), zFilter, "branches/%s/*", gsvn.zBranch);
    blob_appendf(&gsvn.filter, "%s%s/*", gsvn.zBranches, gsvn.zBranch);
    nFilter = strlen(zFilter)-1;
  }
  db_bind_text(&qFiles, ":filter", zFilter);
  db_bind_text(&qFiles, ":filter", blob_str(&gsvn.filter));
  nFilter = blob_size(&gsvn.filter);
  while( db_step(&qFiles)==SQLITE_ROW ){
    const char *zFile = db_column_text(&qFiles, 0);
    int rid = db_column_int(&qFiles, 1);
    const char *zPerm = db_column_text(&qFiles, 2);
    const char *zUuid;
    zUuid = db_text("", "SELECT uuid FROM blob WHERE rid=%d", rid);
    blob_appendf(&manifest, "F %F %s %s\n", zFile+nFilter, zUuid, zPerm);
    fossil_free(zUuid);
  }
  blob_resize(&gsvn.filter, nBaseFilter);
  if( gsvn.parent>=0 ){
    const char *zParentUuid;
    db_bind_int(&qParent, ":rev", gsvn.parent);
    db_step(&qParent);
    zParentUuid = db_column_text(&qParent, 0);
    blob_appendf(&manifest, "P %s\n", zParentUuid);
    if( !gsvn.flatFlag ){

  if( blob_size(pDiff)<4 || memcmp(zDiff, "SVN", 4)!=0 ){
    fossil_fatal("Invalid svndiff0 format");
  }
  zDiff += 4;
  blob_zero(pOut);
  while( zDiff<(blob_buffer(pDiff)+blob_size(pDiff)) ){
    u64 offSrc = svn_get_varint(&zDiff);
    u64 lenSrc = svn_get_varint(&zDiff);
    /*u64 lenSrc =*/ svn_get_varint(&zDiff);
    u64 lenOut = svn_get_varint(&zDiff);
    u64 lenInst = svn_get_varint(&zDiff);
    u64 lenData = svn_get_varint(&zDiff);
    const char *zInst = zDiff;
    const char *zData = zInst+lenInst;
    u64 lenOld = blob_size(pOut);
    blob_resize(pOut, lenOut+lenOld);

  SvnRecord rec;
  int ver;
  const char *zTemp;
  const char *zUuid;
  Stmt addHist;
  Stmt insTag;
  Stmt cpyPath;
  int bHasFiles;

  /* version */
  if( svn_read_rec(pIn, &rec)
   && (zTemp = svn_find_header(rec, "SVN-fs-dump-format-version")) ){
    ver = atoi(zTemp);
    if( ver!=2 && ver!=3 ){
      fossil_fatal("Unknown svn-dump format version: %d", ver);

    " SELECT :rev, :path||substr(tpath, length(:srcpath)+1), trid, tperm"
    " FROM xsrc WHERE tpath>:srcpath||'/' AND tpath<:srcpath||0"
  );
  gsvn.rev = -1;
  while( svn_read_rec(pIn, &rec) ){
    if( (zTemp = svn_find_header(rec, "Revision-number")) ){ /* revision node */
      /* finish previous revision */
      if( gsvn.rev>=0 ){
      if( bHasFiles ){
        svn_create_manifest();
        fossil_free(gsvn.zUser);
        fossil_free(gsvn.zComment);
        fossil_free(gsvn.zDate);
        fossil_free(gsvn.zBranch);
      }
      /* start new revision */
      gsvn.rev = atoi(zTemp);
      gsvn.zUser = mprintf("%s", svn_find_prop(rec, "svn:author"));
      gsvn.zComment = mprintf("%s", svn_find_prop(rec, "svn:log"));
      gsvn.zDate = date_in_standard_format(svn_find_prop(rec, "svn:date"));
      gsvn.parent = -1;
      gsvn.zBranch = 0;
      bHasFiles = 0;
      fossil_print("\rImporting SVN revision: %d", gsvn.rev);
      db_bind_int(&addHist, ":rev", gsvn.rev);
      db_bind_int(&cpyPath, ":rev", gsvn.rev);
    }else
    if( (zTemp = svn_find_header(rec, "Node-path")) ){ /* file/dir node */
      const char *zPath = zTemp;
      const char *zAction = svn_find_header(rec, "Node-action");

        if( zTemp ){
          srcRev = atoi(zTemp);
        }else{
          fossil_fatal("Missing copyfrom-rev");
        }
      }
      if( !gsvn.flatFlag ){
        if( strncmp(zPath, "branches/", 9)==0 ){
          int nBranch;
          zTemp = zPath+9;
        if( strncmp(zPath, gsvn.zBranches, gsvn.lenBranches)==0 ){
          int lenBranch;
          zTemp = zPath+gsvn.lenBranches;
          while( *zTemp && *zTemp!='/' ){ zTemp++; }
          nBranch = zTemp-zPath+9;
          gsvn.zBranch = fossil_malloc(nBranch+1);
          memcpy(gsvn.zBranch, zPath+9, nBranch);
          gsvn.zBranch[nBranch] = '\0';
          lenBranch = zTemp-zPath-gsvn.lenBranches;
          zTemp = zPath+gsvn.lenBranches;
          if( gsvn.zBranch!=0 ){
            if( strncmp(zTemp, gsvn.zBranch, lenBranch)!=0 ){
              fossil_fatal("Commit to multiple branches");
            }
          }else{
            gsvn.zBranch = fossil_malloc(lenBranch+1);
            memcpy(gsvn.zBranch, zTemp, lenBranch);
            gsvn.zBranch[lenBranch] = '\0';
            bHasFiles = 1;
          }
        }else
        if( strncmp(zPath, "trunk/", 6)==0 ){
          gsvn.zBranch = mprintf("trunk");
        }else
        if( strncmp(zPath, gsvn.zTrunk, gsvn.lenTrunk)==0 ){
          if( gsvn.zBranch!=0 ){
            if( strncmp(gsvn.zTrunk, gsvn.zBranch, gsvn.lenTrunk-1)!=0 ){
              fossil_fatal("Commit to multiple branches");
            }
          }else{
        if( strncmp(zPath, "tags/", 5)!=0
         && strcmp(zPath, "branches")!=0
         && strcmp(zPath, "trunk")!=0
            gsvn.zBranch = fossil_malloc(gsvn.lenTrunk);
            memcpy(gsvn.zBranch, gsvn.zTrunk, gsvn.lenTrunk-1);
            gsvn.zBranch[gsvn.lenTrunk-1] = '\0';
         && strcmp(zPath, "tags")!=0){
          fossil_fatal("Write outside repository layout: %s", zPath);
            bHasFiles = 1;
          }
        }
      }
      if( strncmp(zAction, "delete", 6)==0
       || strncmp(zAction, "replace", 7)==0 )
      {
        db_bind_null(&addHist, ":rid");
        db_bind_text(&addHist, ":path", zPath);

          if( zSrcPath ){
            db_bind_int(&cpyPath, ":srcrev", srcRev);
            db_bind_text(&cpyPath, ":path", zPath);
            db_bind_text(&cpyPath, ":srcpath", zSrcPath);
            db_step(&cpyPath);
            db_reset(&cpyPath);
            if( !gsvn.flatFlag ){
              if( strncmp(zPath, "branches/", 9)==0 ){
                zTemp = zPath+9+strlen(gsvn.zBranch);
              if( strncmp(zPath, gsvn.zBranches, gsvn.lenBranches)==0 ){
                zTemp = zPath+gsvn.lenBranches+strlen(gsvn.zBranch);
                if( *zTemp==0 ){
                  gsvn.parent = srcRev;
                }
              }else if( strncmp(zPath, "tags/", 5)==0 ){
                zTemp = zPath+5;
              }else if( strncmp(zPath, gsvn.zTags, gsvn.lenTags)==0 ){
                zTemp = zPath+gsvn.lenTags;
                db_bind_int(&insTag, ":rev", srcRev);
                db_bind_text(&insTag, ":tag", zTemp);
                db_step(&insTag);
                db_reset(&insTag);
              }
            }
          }

** argument.  If no input file is supplied the interchange format
** data is read from standard input.
**
** The following formats are currently understood by this command
**
**   git          Import from the git-fast-export file format
**
**   svn          Import from the svnadmin-dump file format
**   svn          Import from the svnadmin-dump file format. The default
**                behaviour is to treat 3 folders in the SVN root as special,
**                following the common layout of SVN repositories. These are
**                (by default) trunk/, branches/ and tags/
**                Options:
**                  --flat  The whole dump is a single branch. The default
**                          is to use the trunk/branches/tags svn layout
**                  --trunk FOLDER     Name of trunk folder
**                  --branches FOLDER  Name of branches folder
**                  --tags FOLDER      Name of tags folder
**                  --fiter PATH       Path to project root in repository
**                  --flat             The whole dump is a single branch
**
** The --incremental option allows an existing repository to be extended
** with new content.
**
** Options:
**   --incremental  allow importing into an existing repository
**
** See also: export
*/
void import_cmd(void){
  char *zPassword;
  FILE *pIn;
  Stmt q;
  const char *zFilter = find_option("filter", 0, 1);
  int forceFlag = find_option("force", "f", 0)!=0;
  int incrFlag = find_option("incremental", "i", 0)!=0;
  gsvn.zTrunk = find_option("trunk", 0, 1);
  gsvn.zBranches = find_option("branches", 0, 1);
  gsvn.zTags = find_option("tags", 0, 1);
  gsvn.flatFlag = find_option("flat", 0, 0)!=0;

  verify_all_options();
  if( g.argc!=4  && g.argc!=5 ){
    usage("FORMAT REPOSITORY-NAME");
  }
  if( g.argc==5 ){

       "CREATE TEMP TRIGGER xfilesaddtrig AFTER INSERT ON xhist FOR EACH ROW"
       " WHEN new.trid NOTNULL BEGIN INSERT INTO xfiles(tpath,trid,tperm)"
       " VALUES(new.tpath, new.trid, new.tperm); END;"
       "CREATE TEMP TABLE xtags("
       " trev INT, ttag TEXT"
       ");"
    );
    if( gsvn.zTrunk==0 ){ gsvn.zTrunk = "trunk/"; }
    if( gsvn.zBranches==0 ){ gsvn.zBranches = "branches/"; }
    if( gsvn.zTags==0 ){ gsvn.zTags = "tags/"; }
    gsvn.lenTrunk = strlen(gsvn.zTrunk);
    gsvn.lenBranches = strlen(gsvn.zBranches);
    gsvn.lenTags = strlen(gsvn.zTags);
    if( gsvn.zTrunk[gsvn.lenTrunk-1]!='/' ){
      gsvn.zTrunk = mprintf("%s/", gsvn.zTrunk);
      gsvn.lenTrunk++;
    }
    if( gsvn.zBranches[gsvn.lenBranches-1]!='/' ){
      gsvn.zBranches = mprintf("%s/", gsvn.zBranches);
      gsvn.lenBranches++;
    }
    if( gsvn.zTags[gsvn.lenTags-1]!='/' ){
      gsvn.zTags = mprintf("%s/", gsvn.zTags);
      gsvn.lenTags++;
    }
    if( zFilter==0 ){ zFilter = ""; }
    blob_zero(&gsvn.filter);
    blob_set(&gsvn.filter, zFilter);
    svn_dump_import(pIn);
  }

  verify_cancel();
  db_end_transaction(0);
  db_begin_transaction();
  fossil_print("Rebuilding repository meta-data...\n");