Fossil with Commonmark

#include "config.h"
#include "foci.h"
#include <assert.h>

/*
** The schema for the virtual table:
*/
static const char zFociSchema[] = 
@ CREATE TABLE files_of_checkin(
@  checkinID    INTEGER,    -- RID for the checkin manifest
@  filename     TEXT,       -- Name of a file
@  uuid         TEXT,       -- SHA1 hash of the file
@  previousName TEXT,       -- Name of the file in previous checkin
@  prem         TEXT        -- Permissions on the file
@ );
;

#if INTERFACE
/*
** The subclasses of sqlite3_vtab  and sqlite3_vtab_cursor tables
** that implement the files_of_checkin virtual table.
................................................................................

static int fociEof(sqlite3_vtab_cursor *pCursor){
  FociCursor *pCsr = (FociCursor *)pCursor;
  return pCsr->pFile==0;
}

static int fociFilter(
  sqlite3_vtab_cursor *pCursor, 
  int idxNum, const char *idxStr,
  int argc, sqlite3_value **argv
){
  FociCursor *pCur = (FociCursor *)pCursor;
  manifest_destroy(pCur->pMan);
  if( idxNum ){
    pCur->pMan = manifest_get(sqlite3_value_int(argv[0]), CFTYPE_MANIFEST, 0);
................................................................................
    pCur->pMan = 0;
    pCur->iFile = 0;
  }
  return SQLITE_OK;
}

static int fociColumn(
  sqlite3_vtab_cursor *pCursor, 
  sqlite3_context *ctx, 
  int i
){
  FociCursor *pCsr = (FociCursor *)pCursor;
  switch( i ){
    case 0:            /* checkinID */
      sqlite3_result_int(ctx, pCsr->pMan->rid);
      break;

#include "config.h"
#include "foci.h"
#include <assert.h>

/*
** The schema for the virtual table:
*/
static const char zFociSchema[] =
@ CREATE TABLE files_of_checkin(
@  checkinID    INTEGER,    -- RID for the checkin manifest
@  filename     TEXT,       -- Name of a file
@  uuid         TEXT,       -- SHA1 hash of the file
@  previousName TEXT,       -- Name of the file in previous checkin
@  perm         TEXT        -- Permissions on the file
@ );
;

#if INTERFACE
/*
** The subclasses of sqlite3_vtab  and sqlite3_vtab_cursor tables
** that implement the files_of_checkin virtual table.
................................................................................

static int fociEof(sqlite3_vtab_cursor *pCursor){
  FociCursor *pCsr = (FociCursor *)pCursor;
  return pCsr->pFile==0;
}

static int fociFilter(
  sqlite3_vtab_cursor *pCursor,
  int idxNum, const char *idxStr,
  int argc, sqlite3_value **argv
){
  FociCursor *pCur = (FociCursor *)pCursor;
  manifest_destroy(pCur->pMan);
  if( idxNum ){
    pCur->pMan = manifest_get(sqlite3_value_int(argv[0]), CFTYPE_MANIFEST, 0);
................................................................................
    pCur->pMan = 0;
    pCur->iFile = 0;
  }
  return SQLITE_OK;
}

static int fociColumn(
  sqlite3_vtab_cursor *pCursor,
  sqlite3_context *ctx,
  int i
){
  FociCursor *pCsr = (FociCursor *)pCursor;
  switch( i ){
    case 0:            /* checkinID */
      sqlite3_result_int(ctx, pCsr->pMan->rid);
      break;

** merchantability or fitness for a particular purpose.
**
** Author contact information:
**   drh@sqlite.org
**
*******************************************************************************
**
** This file contains code used to import the content of a Git
** repository in the git-fast-import format as a new Fossil
** repository.
*/
#include "config.h"
#include "import.h"
#include <assert.h>

#if INTERFACE
................................................................................
malformed_line:
  trim_newline(zLine);
  fossil_fatal("bad fast-import line: [%s]", zLine);
  return;
}

static struct{





































































































  int rev;                    /* SVN revision number */
  int parentRev;              /* SVN revision number of parent check-in */
  char *zParentBranch;        /* Name of branch 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 {
  char *zKey;
  const char *zVal;
} KeyVal;
typedef struct {
  KeyVal *aHeaders;
................................................................................
  int i;
  for(i=0; i<rec->nHeaders; i++){
    fossil_free(rec->aHeaders[i].zKey);
  }
  fossil_free(rec->aHeaders);
  fossil_free(rec->aProps);
  fossil_free(rec->pRawProps);
  blob_reset(&rec->content);  
}

static int svn_read_headers(FILE *pIn, SvnRecord *rec){
  char zLine[1000];

  rec->aHeaders = 0;
  rec->nHeaders = 0;
................................................................................
    }
  }else{
    rec->contentFlag = 0;
  }
  return 1;
}

static void svn_create_manifest(
){
  Blob manifest;
  static Stmt insRev;
  static Stmt qParent;
  static Stmt qParent2;
  static Stmt qFiles;
  static Stmt qTags;
................................................................................
        *zOut++ = *zCpy++;
      }
    }
    zDiff += lenData;
  }
}

static char *svn_extract_branch(const char *zPath){
  int nFilter = blob_size(&gsvn.filter);
  char *zBranch = 0;
  if( strncmp(zPath, blob_str(&gsvn.filter), nFilter)==0 ){
    if( strncmp(zPath+nFilter, gsvn.zBranches, gsvn.lenBranches)==0 ){
      int lenBranch;
      const char *zTemp = zPath+nFilter+gsvn.lenBranches;
      while( *zTemp && *zTemp!='/' ){ zTemp++; }
      lenBranch = zTemp-(zPath+nFilter+gsvn.lenBranches);
      zTemp = zPath+nFilter+gsvn.lenBranches;
      zBranch = fossil_malloc(lenBranch+1);
      memcpy(zBranch, zTemp, lenBranch);
      zBranch[lenBranch] = '\0';
    }else
    if( strncmp(zPath+nFilter, gsvn.zTrunk, gsvn.lenTrunk-1)==0 ){
      zBranch = mprintf("trunk");
    }
  }
  return zBranch;


















}

/*
** 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;
  const char *zTemp;
  const char *zUuid;


  Stmt addHist;
  Stmt insTag;
  Stmt cpyPath;
  Stmt delPath;
  int bHasFiles = 0;
  int nFilter = blob_size(&gsvn.filter);

  /* 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);
................................................................................
  }
  svn_free_rec(&rec);
  /* UUID */
  if( !svn_read_rec(pIn, &rec) || !(zUuid = svn_find_header(rec, "UUID")) ){
    fossil_fatal("Missing UUID!");
  }
  svn_free_rec(&rec);

  /* content */
  db_prepare(&addHist,
    "INSERT INTO xhist (trev, tpath, trid, tperm) "
    "VALUES(:rev, :path, :rid, :perm)"

  );
  db_prepare(&insTag, "INSERT INTO xtags (trev, ttag) VALUES(:rev, :tag)");
  db_prepare(&cpyPath,
    "WITH xsrc AS (SELECT * FROM ("
    "  SELECT tpath, trid, tperm, max(trev) trev FROM xhist"
    "  WHERE trev<=:srcrev GROUP BY tpath"
    " ) WHERE trid NOTNULL)"
    "INSERT INTO xhist (trev, tpath, trid, tperm)"
    " SELECT :rev, :path||substr(tpath, length(:srcpath)+1), trid, tperm"
    " FROM xsrc WHERE tpath>:srcpath||'/' AND tpath<:srcpath||'0'"
  );
  db_prepare(&delPath,
    "INSERT INTO xhist (trev, tpath, trid, tperm)"
    " SELECT :rev, tpath, NULL, NULL"

    " FROM xfiles WHERE (tpath>:path||'/' AND tpath<:path||'0') OR tpath=:path"




  );
  gsvn.rev = -1;
  while( svn_read_rec(pIn, &rec) ){
    if( (zTemp = svn_find_header(rec, "Revision-number")) ){ /* revision node */
      /* finish previous revision */
      const char *zDate = NULL;
      if( bHasFiles ){
        svn_create_manifest();
      }
      fossil_free(gsvn.zUser);
      fossil_free(gsvn.zComment);
      fossil_free(gsvn.zDate);
      fossil_free(gsvn.zBranch);
      fossil_free(gsvn.zParentBranch);

      /* 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 ){
        gsvn.zDate = date_in_standard_format(zDate);
      }
      gsvn.parentRev = -1;
      gsvn.zParentBranch = 0;
      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);
      db_bind_int(&delPath, ":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");
      const char *zKind = svn_find_header(rec, "Node-kind");
      const char *zSrcPath = svn_find_header(rec, "Node-copyfrom-path");
      const char *zPerm = svn_find_prop(rec, "svn:executable") ? "x" : 0;




      int deltaFlag = 0;
      int srcRev = 0;









      if( (zTemp = svn_find_header(rec, "Text-delta")) ){
        deltaFlag = strncmp(zTemp, "true", 4)==0;
      }
      if( zSrcPath ){
        zTemp = svn_find_header(rec, "Node-copyfrom-rev");
        if( zTemp ){
          srcRev = atoi(zTemp);
        }else{
          fossil_fatal("Missing copyfrom-rev");
        }
      }
      if( !gsvn.flatFlag ){
        char *zBranch;
        if( (zBranch=svn_extract_branch(zPath))!=0 ){
          if( gsvn.zBranch!=0 ){
            if( strcmp(zBranch, gsvn.zBranch)!=0
             && strncmp(zAction, "delete", 6)!=0)
            {
              fossil_fatal("Commit to multiple branches");
            }
            fossil_free(zBranch);
          }else{
            gsvn.zBranch = zBranch;
          }
        }
      }
      if( strncmp(zAction, "delete", 6)==0
       || strncmp(zAction, "replace", 7)==0 )
      {
        db_bind_text(&delPath, ":path", zPath);

        db_step(&delPath);
        db_reset(&delPath);
        bHasFiles = 1;
      } /* 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 ){
            db_bind_int(&cpyPath, ":srcrev", srcRev);


            db_bind_text(&cpyPath, ":path", zPath);

            db_bind_text(&cpyPath, ":srcpath", zSrcPath);

            db_step(&cpyPath);
            db_reset(&cpyPath);
            bHasFiles = 1;
            if( !gsvn.flatFlag ){
              if( strncmp(zPath+nFilter, gsvn.zBranches, gsvn.lenBranches)==0 ){
                zTemp = zPath+nFilter+gsvn.lenBranches+strlen(gsvn.zBranch);
                if( *zTemp==0 ){
                  gsvn.parentRev = srcRev;
                  gsvn.zParentBranch = svn_extract_branch(zSrcPath);
                }
              }else if( strncmp(zPath+nFilter, gsvn.zTags, gsvn.lenTags)==0 ){
                zTemp = zPath+nFilter+gsvn.lenTags;
                db_bind_int(&insTag, ":rev", srcRev);
                db_bind_text(&insTag, ":tag", zTemp);
                db_step(&insTag);
                db_reset(&insTag);
              }
            }
          }
        }else{
          int rid = 0;
          if( zSrcPath ){
            rid = db_int(0, "SELECT trid, max(trev) FROM xhist"
                            " WHERE trev<=%d AND tpath=%Q", srcRev, zSrcPath);
            if( rid==0 ){
              fossil_fatal("Reference to non-existent path/revision");
            }


          }
          if( deltaFlag ){
            Blob deltaSrc;
            Blob target;
            if( rid!=0 ){
              content_get(rid, &deltaSrc);
            }else{
................................................................................
          db_bind_text(&addHist, ":path", zPath);
          db_bind_text(&addHist, ":perm", zPerm);
          db_step(&addHist);
          db_reset(&addHist);
          bHasFiles = 1;
        }
      }else
      if( strncmp(zAction, "delete", 6)!=0 ){ /* already did this above */
        fossil_fatal("Unknown Node-action");
      }
    }else{
      fossil_fatal("Unknown record type");
    }
    svn_free_rec(&rec);
  }
................................................................................
** 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. 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:
**                  --trunk FOLDER     Name of trunk folder
**                  --branches FOLDER  Name of branches folder
**                  --tags FOLDER      Name of tags folder
**                  --filter 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 lenFilter;
  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 ){
    pIn = fossil_fopen(g.argv[4], "rb");
................................................................................
      import_reset(0);
    }
    db_finalize(&q);
  }else
  if( strncmp(g.argv[2], "svn", 3)==0 ){
    db_multi_exec(
       "CREATE TEMP TABLE xrevisions("
       " trev INTEGER PRIMARY KEY, tbranch TEXT, tuuid TEXT"
       ");"
       "CREATE TEMP TABLE xhist("
       " trev INT, tpath TEXT NOT NULL, trid TEXT, tperm TEXT,"
       " UNIQUE (trev, tpath) ON CONFLICT REPLACE"
       ");"
       "CREATE TEMP TABLE xfiles("
       " tpath TEXT NOT NULL, trid TEXT, tperm TEXT,"
       " UNIQUE (tpath) ON CONFLICT REPLACE"
       ");"
       "CREATE TEMP TRIGGER xfilesdeltrig AFTER INSERT ON xhist FOR EACH ROW"
       " WHEN new.trid ISNULL"
       " BEGIN DELETE FROM xfiles WHERE xfiles.tpath=new.tpath; END;"
       "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 = ""; }
    lenFilter = strlen(zFilter);
    blob_zero(&gsvn.filter);
    blob_set(&gsvn.filter, zFilter);
    if( lenFilter>0 && zFilter[lenFilter-1]!='/' ){
      blob_append(&gsvn.filter, "/", 1);
    }
    svn_dump_import(pIn);
  }

  verify_cancel();
  db_end_transaction(0);
  db_begin_transaction();

** merchantability or fitness for a particular purpose.
**
** Author contact information:
**   drh@sqlite.org
**
*******************************************************************************
**
** This file contains code used to import the content of a Git/SVN
** repository in the git-fast-import/svn-dump formats as a new Fossil
** repository.
*/
#include "config.h"
#include "import.h"
#include <assert.h>

#if INTERFACE
................................................................................
malformed_line:
  trim_newline(zLine);
  fossil_fatal("bad fast-import line: [%s]", zLine);
  return;
}

static struct{
  char *zBranch;              /* Name of a branch for a commit */
  char *zDate;                /* Date/time stamp */
  char *zUser;                /* User name */
  char *zComment;             /* Comment of a commit */
  char *zFrom;                /* from value as a UUID */
  int nMerge;                 /* Number of merge values */
  int nMergeAlloc;            /* Number of slots in azMerge[] */
  char **azMerge;             /* Merge values */
  int nFile;                  /* Number of aFile values */
  int nFileAlloc;             /* Number of slots in aFile[] */
  ImportFile *aFile;          /* Information about files in a commit */
  int fromLoaded;             /* True zFrom content loaded into aFile[] */
} gsvn;

/*
** Create a new entry in the gsvn.aFile[] array
*/
static ImportFile *svn_import_add_file(){
  ImportFile *pFile;
  if( gsvn.nFile>=gsvn.nFileAlloc ){
    gsvn.nFileAlloc = gsvn.nFileAlloc*2 + 100;
    gsvn.aFile = fossil_realloc(gsvn.aFile, gsvn.nFileAlloc*sizeof(gsvn.aFile[0]));
  }
  pFile = &gsvn.aFile[gsvn.nFile++];
  memset(pFile, 0, sizeof(*pFile));
  return pFile;
}

/*
** Load all file information out of the gsvn.zFrom check-in
*/
static void svn_import_prior_files(void){
  Manifest *p;
  int rid;
  ManifestFile *pOld;
  ImportFile *pNew;
  if( gsvn.fromLoaded ) return;
  gsvn.fromLoaded = 1;
  if( gsvn.zFrom==0 && gsvn.zPrevCheckin!=0
   && fossil_strcmp(gsvn.zBranch, gsvn.zPrevBranch)==0
  ){
     gsvn.zFrom = gsvn.zPrevCheckin;
     gsvn.zPrevCheckin = 0;
  }
  if( gsvn.zFrom==0 ) return;
  rid = fast_uuid_to_rid(gsvn.zFrom);
  if( rid==0 ) return;
  p = manifest_get(rid, CFTYPE_MANIFEST, 0);
  if( p==0 ) return;
  manifest_file_rewind(p);
  while( (pOld = manifest_file_next(p, 0))!=0 ){
    pNew = import_add_file();
    pNew->zName = fossil_strdup(pOld->zName);
    pNew->isExe = pOld->zPerm && strstr(pOld->zPerm, "x")!=0;
    pNew->isLink = pOld->zPerm && strstr(pOld->zPerm, "l")!=0;
    pNew->zUuid = fossil_strdup(pOld->zUuid);
    pNew->isFrom = 1;
  }
  manifest_destroy(p);
}

/*
** Deallocate the state information.
**
** The azMerge[] and aFile[] arrays are zeroed but allocated space is
** retained unless the freeAll flag is set.
*/
static void svn_import_reset(int freeAll){
  int i;
//  gsvn.xFinish = 0;
//  fossil_free(gsvn.zTag); gsvn.zTag = 0;
  fossil_free(gsvn.zBranch); gsvn.zBranch = 0;
//  fossil_free(gsvn.aData); gsvn.aData = 0;
//  fossil_free(gsvn.zMark); gsvn.zMark = 0;
  fossil_free(gsvn.zDate); gsvn.zDate = 0;
  fossil_free(gsvn.zUser); gsvn.zUser = 0;
  fossil_free(gsvn.zComment); gsvn.zComment = 0;
  fossil_free(gsvn.zFrom); gsvn.zFrom = 0;
//  fossil_free(gsvn.zFromMark); gsvn.zFromMark = 0;
  for(i=0; i<gsvn.nMerge; i++){
    fossil_free(gsvn.azMerge[i]); gsvn.azMerge[i] = 0;
  }
  gsvn.nMerge = 0;
  for(i=0; i<gsvn.nFile; i++){
    fossil_free(gsvn.aFile[i].zName);
    fossil_free(gsvn.aFile[i].zUuid);
    fossil_free(gsvn.aFile[i].zPrior);
  }
  memset(gsvn.aFile, 0, gsvn.nFile*sizeof(gsvn.aFile[0]));
  gsvn.nFile = 0;
  if( freeAll ){
//    fossil_free(gsvn.zPrevBranch);
//    fossil_free(gsvn.zPrevCheckin);
    fossil_free(gsvn.azMerge);
    fossil_free(gsvn.aFile);
    memset(&gsvn, 0, sizeof(gsvn));
  }
//  gsvn.xFinish = finish_noop;
}

static struct{
  int rev;                    /* SVN revision number */
//  int parentRev;              /* SVN revision number of parent check-in */
//  char *zParentBranch;        /* Name of branch 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 */

} gsvn;
typedef struct {
  char *zKey;
  const char *zVal;
} KeyVal;
typedef struct {
  KeyVal *aHeaders;
................................................................................
  int i;
  for(i=0; i<rec->nHeaders; i++){
    fossil_free(rec->aHeaders[i].zKey);
  }
  fossil_free(rec->aHeaders);
  fossil_free(rec->aProps);
  fossil_free(rec->pRawProps);
  blob_reset(&rec->content);
}

static int svn_read_headers(FILE *pIn, SvnRecord *rec){
  char zLine[1000];

  rec->aHeaders = 0;
  rec->nHeaders = 0;
................................................................................
    }
  }else{
    rec->contentFlag = 0;
  }
  return 1;
}

static void svn_finish_revision(
){
  Blob manifest;
  static Stmt insRev;
  static Stmt qParent;
  static Stmt qParent2;
  static Stmt qFiles;
  static Stmt qTags;
................................................................................
        *zOut++ = *zCpy++;
      }
    }
    zDiff += lenData;
  }
}

/*
** Extract the name of the branch or tag that the given path is on.
** Returns: 1 - It is on the trunk
**          2 - It is on a branch
**          3 - It is a tag
**          0 - It is none of the above
 */
static int *svn_parse_path(char *zPath, char **zBranch, char **zFile){
  if( strncmp(zPath, gsvn.zTrunk, gsvn.lenTrunk)==0 ){
    *zBranch = "trunk";
    *zFile = zPath+gsvn.lenTrunk;
    return 1;
  }else
  if( strncmp(zPath, gsvn.zBranches, gsvn.lenBranches)==0 ){
    *zFile = *zBranch = zPath+gsvn.lenBranches;
    while( **zFile && **zFile!='/' ){ (*zFile)++; }
    if( *zFile ){
      **zFile = '\0';
      (*zFile)++;
    }else{
      *zFile = 0;
    }
    return 2;
  }else
  if( strncmp(zPath, gsvn.zTags, gsvn.lenTags)==0 ){
    *zFile = *zBranch = zPath+gsvn.lenTags;
    while( **zFile && **zFile!='/' ){ (*zFile)++; }
    if( *zFile ){
      **zFile = '\0';
      (*zFile)++;
    }else{
      *zFile = 0;
    }
    return 3;
  }
  *zFile = *zBranch = 0;
  return 0;
}

/*
** 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);
................................................................................
  }
  svn_free_rec(&rec);
  /* UUID */
  if( !svn_read_rec(pIn, &rec) || !(zUuid = svn_find_header(rec, "UUID")) ){
    fossil_fatal("Missing UUID!");
  }
  svn_free_rec(&rec);

  /* content */
  db_prepare(&addFile,

    "INSERT INTO xfiles (tpath, tbranch, tuuid, tperm)"
    " VALUES(:path, :branch, :uuid, :perm)"
  );

  db_prepare(&delPath,
    "DELETE FROM xfiles"
    " WHERE (tpath=:path OR (tpath>:path||'/' AND tpath<:path||'0'))"
    "     AND tbranch=:branch"
  );
  db_prepare(&addSrc,
    "INSERT INTO xsrc (tpath, tbranch, tsrc, tsrcbranch, tsrcrev)"
    " VALUES(:path, :branch, :srcpath, :srcbranch, :srcrev)"
  );
  db_prepare(&addBranch,
    "INSERT INTO xchanges (tbranch, ttype) VALUES(:branch, :type)"

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



      fossil_print("\rImporting SVN revision: %d", gsvn.rev);



    }else
    if( (zTemp = svn_find_header(rec, "Node-path")) ){ /* file/dir node */

      const char *zAction = svn_find_header(rec, "Node-action");
      const char *zKind = svn_find_header(rec, "Node-kind");
      const char *zSrcPath = svn_find_header(rec, "Node-copyfrom-path");
      const char *zPerm = svn_find_prop(rec, "svn:executable") ? "x" : 0;
      char *zBranch;
      char *zFile;
      char *zSrcBranch;
      char *zSrcFile;
      int deltaFlag = 0;
      int srcRev = 0;
      int branchType = svn_parse_path(zTemp, &zBranch, &zFile);
      if( branchType==0 ){
        svn_free_rec(&rec);
        continue;
      }
      db_bind_text(&addBranch, ":branch", zBranch);
      db_bind_int(&addBranch, ":type", branchType);
      db_step(&addBranch);
      db_reset(&addBranch);
      if( (zTemp = svn_find_header(rec, "Text-delta")) ){
        deltaFlag = strncmp(zTemp, "true", 4)==0;
      }
      if( zSrcPath ){
        zTemp = svn_find_header(rec, "Node-copyfrom-rev");
        if( zTemp ){
          srcRev = atoi(zTemp);
        }else{
          fossil_fatal("Missing copyfrom-rev");
        }
        if( svn_extract_branch(zSrcPath, &zSrcBranch, &zSrcFile)==0 ){
          fossil_fatal("Copy from path outside the import paths");
        }
        db_bind_text(&addSrc, ":path", zFile);
        db_bind_text(&addSrc, ":branch", zBranch);
        db_bind_text(&addSrc, ":srcpath", zSrcFile);
        db_bind_text(&addSrc, ":srcbranch", zSrcBranch);
        db_bind_int(&addSrc, ":srcrev", srcRev);
        db_step(&addSrc);
        db_reset(&addSrc);





      }
      if( strncmp(zAction, "delete", 6)==0
       || strncmp(zAction, "replace", 7)==0 )
      {
        db_bind_text(&delPath, ":path", zFile);
        db_bind_text(&delPath, ":branch", zBranch);
        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 xfoci"

                            " WHERE chekinID=%d AND filename=%Q",
                         srcRid, zSrcFile)
          }
          if( deltaFlag ){
            Blob deltaSrc;
            Blob target;
            if( rid!=0 ){
              content_get(rid, &deltaSrc);
            }else{
................................................................................
          db_bind_text(&addHist, ":path", zPath);
          db_bind_text(&addHist, ":perm", zPerm);
          db_step(&addHist);
          db_reset(&addHist);
          bHasFiles = 1;
        }
      }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);
  }
................................................................................
** 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. The default
**                behaviour (unless overridden by --flat) 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:
**                  --trunk FOLDER     Name of trunk folder
**                  --branches FOLDER  Name of branches folder
**                  --tags FOLDER      Name of tags folder
**                  --base 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 *zBase = find_option("base", 0, 1);
  int lenFilter;
  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);
  int 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 ){
    pIn = fossil_fopen(g.argv[4], "rb");
................................................................................
      import_reset(0);
    }
    db_finalize(&q);
  }else
  if( strncmp(g.argv[2], "svn", 3)==0 ){
    db_multi_exec(
       "CREATE TEMP TABLE xrevisions("
       " trev INTEGER, tbranch TEXT, trid INT, PRIMARY KEY(tbranch, trev)"
       ");"
       "CREATE TEMP TABLE xfiles("
       " tpath TEXT, tbranch TEXT, tuuid TEXT, tperm TEXT,"
       " UNIQUE (tbranch, tpath) ON CONFLICT REPLACE"
       ");"
       "CREATE TEMP TABLE xsrc("
       " tpath TEXT, tbranch TEXT, tsrc TEXT, tsrcbranch TEXT, tsrcrev INT"

       ");"






       "CREATE TEMP TABLE xchanged("

       " tbranch TEXT, ttype INT,"
       " UNIQUE (tbranch) ON CONFLICT REPLACE"
       ");"
       "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);
    }
    if( flatFlag ){
      gsvn.zTrunk = zBase;
      gsvn.zBranches = 0;
      gsvn.zTags = 0;
      gsvn.lenTrunk = strlen(zBase);
      gsvn.lenBranches = 0;
      gsvn.lenTags = 0;
    }else{
      if( gsvn.zTrunk==0 ){ gsvn.zTrunk = "trunk/"; }
      if( gsvn.zBranches==0 ){ gsvn.zBranches = "branches/"; }
      if( gsvn.zTags==0 ){ gsvn.zTags = "tags/"; }
      gsvn.zTrunk = mprintf("%s%s", zBase, gsvn.zTrunk);
      gsvn.zBranches = mprintf("%s%s", zBase, gsvn.zBranches);
      gsvn.zTags = mprintf("%s%s", zBase, gsvn.zTags);
      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++;
      }






    }
    svn_dump_import(pIn);
  }

  verify_cancel();
  db_end_transaction(0);
  db_begin_transaction();