Fossil

    rec->contentFlag = 0;
  }
  return 1;
}

static void svn_finish_revision(){
  Blob manifest;

  static Stmt insRev;

  Blob mcksum;

  blob_zero(&manifest);
  db_static_prepare(&getChanges, "SELECT tbranch, ttype FROM xchanged");


  db_static_prepare(&getFiles, "SELECT tpath, tuuid, tperm,"
                               " tsrc, tsrcbranch, trev tsrcrev"
                               " FROM xfiles, xsrc"
                               " ON tpath, tbranch)"
                               " WHERE tbranch=:branch ORDER BY tpath");
  db_static_prepare(&setRid, "REPLACE INTO xrevisions(trev, tbranch, trid)"
                             " VALUES (%d, :branch, :rid)", gsvn.rev);

  if( !gsvn.flatFlag ){
    if( gsvn.parentRev<0 ){
      gsvn.parentRev = db_int(-1, "SELECT ifnull(max(trev),-1) FROM xrevisions "
                                  "WHERE tbranch=%Q", gsvn.zBranch);
      if( gsvn.parentRev<0 ){
        gsvn.parentRev =
            db_int(-1, "SELECT ifnull(max(trev),-1) FROM xrevisions");
      }
      gsvn.zParentBranch = gsvn.zBranch;
    }else if( gsvn.zParentBranch==0 ){
      gsvn.zParentBranch = mprintf("trunk");
    }
    /*db_bind_int(&insRev, ":rev", gsvn.rev);
    db_bind_text(&insRev, ":branch", gsvn.zBranch);
    db_bind_int(&insRev, ":rid", 0);
    db_step(&insRev);
    db_reset(&insRev);*/
  }else{
    static int prevRev = -1;
    gsvn.parentRev = prevRev;
    gsvn.zParentBranch = gsvn.zBranch = "";
    prevRev = gsvn.rev;
  }

  if( gsvn.zComment ){
    blob_appendf(&manifest, "C %F\n", gsvn.zComment);
  }else{
    blob_append(&manifest, "C (no\\scomment)\n", 16);
  }
  if( gsvn.zDate ){
    blob_appendf(&manifest, "D %s\n", gsvn.zDate);
  }else{
    goto skip_revision;
  }
  nFilter = blob_size(&gsvn.filter)-1;
  db_bind_text(&qFiles, ":filter", blob_str(&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);
    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);
  }
  db_reset(&qFiles);
  if( gsvn.parentRev>=0 ){
    const char *zParentUuid;
    db_bind_int(&qParent, ":rev", gsvn.parentRev);
    db_bind_text(&qParent, ":branch", gsvn.zParentBranch);
    db_step(&qParent);
    zParentUuid = db_column_text(&qParent, 0);
    if( zParentUuid==0 ){
      db_bind_text(&qParent2, ":branch", gsvn.zParentBranch);
      db_step(&qParent2);
      zParentUuid = db_column_text(&qParent2, 0);
    }


    blob_appendf(&manifest, "P %s\n", zParentUuid);
    if( !gsvn.flatFlag ){
      if( strcmp(gsvn.zBranch, gsvn.zParentBranch)!=0 ){
        blob_appendf(&manifest, "T *branch * %F\n", gsvn.zBranch);
        blob_appendf(&manifest, "T *sym-%F *\n", gsvn.zBranch);
        zParentBranch = mprintf("%F", gsvn.zParentBranch);
      }else{
        zParentBranch = 0;
      }
    }
    db_reset(&qParent);
    db_reset(&qParent2);
  }else{
    blob_appendf(&manifest, "T *branch * trunk\n");
    blob_appendf(&manifest, "T *sym-trunk *\n");
  }
  db_bind_int(&qTags, ":rev", gsvn.rev);
  while( db_step(&qTags)==SQLITE_ROW ){
    const char *zTag = db_column_text(&qTags, 0);
    blob_appendf(&manifest, "T +sym-%s *\n", zTag);
  }
  db_reset(&qTags);
  blob_appendf(&manifest, "T +sym-svn-rev-%d *\n", gsvn.rev);
  if( zParentBranch ) {
    blob_appendf(&manifest, "T -sym-%s *\n", zParentBranch);
    fossil_free(zParentBranch);
  }
  if( gsvn.zUser ){
    blob_appendf(&manifest, "U %F\n", gsvn.zUser);
  }else{
    const char *zUserOvrd = find_option("user-override",0,1);
    blob_appendf(&manifest, "U %F\n", zUserOvrd ? zUserOvrd : login_name());
  }
  md5sum_blob(&manifest, &mcksum);
  blob_appendf(&manifest, "Z %b\n", &mcksum);
  blob_reset(&mcksum);



  rid = content_put(&manifest);
  db_bind_int(&insRev, ":rev", gsvn.rev);
  db_bind_text(&insRev, ":branch", gsvn.zBranch);
  db_bind_int(&insRev, ":rid", rid);
  db_step(&insRev);
  db_reset(&insRev);

skip_revision:
  blob_resize(&gsvn.filter, nBaseFilter);
  if( gsvn.zParentBranch == gsvn.zBranch ){
    gsvn.zParentBranch = 0;
  }
  if( gsvn.flatFlag ){
    gsvn.zBranch = 0;
  }
  blob_reset(&manifest);

}

static u64 svn_get_varint(const char **pz){
  unsigned int v = 0;
  do{
    v = (v<<7) | ((*pz)[0]&0x7f);
  }while( (*pz)++[0]&0x80 );

    }else{
      *zFile = 0;
    }
    type = 3;
  }
  if( type>0 ){
    branchId = db_int(0,
                      "SELECT tid FROM xbranches WHERE tbranch=%Q AND ttype=%d",
                      zBranch, branchType);
    if( branchId==0 ){
      db_multi_exec("INSERT INTO xbranches (tbranch, ttype) VALUES(%Q, %d)",
                    zBranch, branchType);
      branchId = db_last_insert_rowid();
    }
  }
  return branchId;
}

/*
** Read the svn-dump format from pIn and insert the corresponding
** content into the database.
*/
static void svn_dump_import(FILE *pIn){
  SvnRecord rec;
  int ver;
  char *zTemp;
  const char *zUuid;
  Stmt addFile;
  Stmt delPath;
  Stmt addSrc;
  Stmt addBranch;
  Stmt cpyPath;


  /* 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);

  );
  db_prepare(&delPath,
    "DELETE FROM xfiles"
    " WHERE (tpath=:path OR (tpath>:path||'/' AND tpath<:path||'0'))"
    "     AND tbranch=:branch"
  );
  db_prepare(&addRev,
    "INSERT OR IGNORE INTO xrevisions (trev, tbranch, tparent)"
    " VALUES(:rev, :branch, :parent)"
  );
  db_prepare(&cpyPath,
    "INSERT INTO xfiles (tpath, tbranch, tuuid, tperm)"
    " SELECT :path||substr(filename, length(:srcpath)+1), :branch, uuid, perm"
    " FROM xfoci"
    " WHERE chekinID=:rid AND filename>:srcpath||'/' AND filename<:srcpath||'0'"



  );
  gsvn.rev = -1;
  while( svn_read_rec(pIn, &rec) ){
    if( (zTemp = svn_find_header(rec, "Revision-number")) ){ /* revision node */
      /* finish previous revision */
      char *zDate = NULL;
      if( gsvn.rev>=0 ){
        svn_finish_revision();
        fossil_free(gsvn.zUser);
        fossil_free(gsvn.zComment);
        fossil_free(gsvn.zDate);
      }
      /* 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"));
      zDate = svn_find_prop(rec, "svn:date");
      if( zDate ){
        zDate = date_in_standard_format(zDate);


      }
      gsvn.zDate = zDate;
      db_bind_int(&addRev, ":rev", gsvn.rev);
      fossil_print("\rImporting SVN revision: %d", gsvn.rev);
    }else
    if( (zTemp = svn_find_header(rec, "Node-path")) ){ /* file/dir node */
      char *zAction = svn_find_header(rec, "Node-action");
      char *zKind = svn_find_header(rec, "Node-kind");
      char *zSrcPath = svn_find_header(rec, "Node-copyfrom-path");

          fossil_fatal("Copy from path outside the import paths");
        }
      }
      if( strncmp(zAction, "delete", 6)==0
       || strncmp(zAction, "replace", 7)==0 )
      {
        db_bind_text(&delPath, ":path", zFile);
        db_bind_text(&delPath, ":branch", branchId);
        db_step(&delPath);
        db_reset(&delPath);



      } /* no 'else' here since 'replace' does both a 'delete' and an 'add' */
      if( strncmp(zAction, "add", 3)==0
       || strncmp(zAction, "replace", 7)==0 )
      {
        if( zKind==0 ){
          fossil_fatal("Missing Node-kind");
        }else if( strncmp(zKind, "dir", 3)==0 ){
          if( zSrcPath ){
            int srcRid = db_int(0, "SELECT trid, max(trev) FROM xrevisions"
                                   " WHERE trev<=%d AND tbranch=%Q",
                                srcRev, zSrcBranch);
            db_bind_text(&cpyPath, ":path", zFile);
            db_bind_text(&cpyPath, ":branch", zBranch);
            db_bind_text(&cpyPath, ":srcpath", zSrcFile);
            db_bind_int(&cpyPath, ":rid", srcRid);
            db_step(&cpyPath);
            db_reset(&cpyPath);










          }
        }else{
          int rid = 0;
          if( zSrcPath ){
            int srcRid = db_int(0, "SELECT trid, max(trev) FROM xrevisions"
                            " WHERE trev<=%d AND tbranch=%Q",
                         srcRev, zSrcBranch);
            rid = db_int(0, "SELECT rid FROM blob WHERE uuid=("
                            " SELECT uuid FROM xfoci"
                            "  WHERE chekinID=%d AND filename=%Q"
                            ")",
                         srcRid, zSrcFile);
          }
          if( deltaFlag ){
            Blob deltaSrc;
            Blob target;
            if( rid!=0 ){
              content_get(rid, &deltaSrc);
            }else{
              blob_zero(&deltaSrc);
            }
            svn_apply_svndiff(&rec.content, &deltaSrc, &target);
            rid = content_put(&target);
          }else if( rec.contentFlag ){
            rid = content_put(&rec.content);
          }
          db_bind_text(&addFile, ":path", zFile);
          db_bind_text(&addFile, ":branch", zBranch);
          db_bind_int(&addFile, ":rid", rid);
          db_bind_text(&addFile, ":perm", zPerm);
          db_step(&addFile);
          db_reset(&addFile);



        }
      }else
      if( strncmp(zAction, "change", 6)==0 ){
        int rid = 0;
        if( zKind==0 ){
          fossil_fatal("Missing Node-kind");
        }
        if( strncmp(zKind, "dir", 3)!=0 ){
          if( deltaFlag ){
            Blob deltaSrc;
            Blob target;
            rid = db_int(0, "SELECT rid FROM blob WHERE uuid=("
                            " SELECT uuid FROM xfiles"
                            "  WHERE tpath=%Q AND tbranch=%Q"
                            ")", zFile, zBranch);
            content_get(rid, &deltaSrc);
            svn_apply_svndiff(&rec.content, &deltaSrc, &target);
            rid = content_put(&target);
          }else{
            rid = content_put(&rec.content);
          }
          db_bind_text(&addFile, ":path", zFile);
          db_bind_text(&addFile, ":branch", zBranch);
          db_bind_int(&addFile, ":rid", rid);
          db_bind_text(&addFile, ":perm", zPerm);
          db_step(&addFile);
          db_reset(&addFile);



        }
      }else
      if( strncmp(zAction, "delete", 6)!=0 ){ /* already did this one above */
        fossil_fatal("Unknown Node-action");
      }
    }else{
      fossil_fatal("Unknown record type");
    }
    svn_free_rec(&rec);
  }
  svn_finish_revision();
  fossil_free(gsvn.zUser);
  fossil_free(gsvn.zComment);
  fossil_free(gsvn.zDate);
  db_finalize(&addFile);
  db_finalize(&delPath);
  db_finalize(&addSrc);
  db_finalize(&addBranch);
  db_finalize(&cpyPath);
  fossil_print(" Done!\n");
}

/*
** COMMAND: import
**
** Usage: %fossil import FORMAT ?OPTIONS? NEW-REPOSITORY ?INPUT-FILE?

  if( strncmp(g.argv[2], "svn", 3)==0 ){
    db_multi_exec(
       "CREATE TEMP TABLE xrevisions("
       " trev INTEGER, tbranch INT, trid INT, tparent INT,"
       " UNIQUE(tbranch, trev), UNIQUE(trid)"
       ");"
       "CREATE TEMP TABLE xfiles("
       " tpath TEXT, tbranch INT, tuuid TEXT, tperm TEXT, tsrcpath TEXT"
       " UNIQUE (tbranch, tpath) ON CONFLICT REPLACE"
       ");"
       "CREATE TEMP TABLE xbranches("
       " tid INTEGER PRIMARY KEY, tbranch TEXT, ttype INT,"
       " UNIQUE(tbranch, ttype)"
       ");"
       "CREATE VIRTUAL TABLE temp.xfoci USING files_of_checkin;"
    );
    if( zBase==0 ){ zBase = ""; }
    if( strlen(zBase)>0 ){
      if( zBase[strlen(zBase)-1]!='/' ){
        zBase = mprintf("%s/", zBase);