Fossil

    va_start(ap, zFormat);
    rc = db_vprepare(pStmt, 0, zFormat, ap);
    pStmt->pNext = db.pAllStmt;
    pStmt->pPrev = 0;
    if( db.pAllStmt ) db.pAllStmt->pPrev = pStmt;
    db.pAllStmt = pStmt;
    va_end(ap);


  }
  return rc;
}

/*
** Return the index of a bind parameter
*/

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










typedef struct {
  const char *zKey;
  const char *zVal;
} KeyVal;
typedef struct {
  KeyVal *aHeaders;
  int nHeaders;

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

static void svn_create_manifests(int flatFlag){

  Blob manifest;
  Stmt qRev;
  Stmt qParent;
  Stmt qFiles;
  Stmt qTags;
  Stmt setUuid;

  if( !flatFlag ){
    db_multi_exec("DELETE FROM xrevisions WHERE tbranch ISNULL;"
                  "UPDATE xrevisions SET tparent=("
                  "  SELECT ifnull(max(trev),-1) FROM xrevisions t"
                  "  WHERE t.trev<xrevisions.trev"
                  "    AND t.tbranch=xrevisions.tbranch"
                  " )"
                  " WHERE tparent ISNULL;"
                  "WITH xprefix AS ( "
                  "  SELECT trev, CASE tbranch WHEN 'trunk' THEN 'trunk/'"
                  "  ELSE 'branches/'||tbranch||'/' END xpref"
                  "  FROM xrevisions"

                  " ), "
                  " x AS (SELECT trev xrev, xpref, length(xpref) xlen "
                  " FROM xprefix) "
                  " UPDATE xfiles SET tpath= "
                  " CASE substr(tpath,1,(SELECT xlen FROM x WHERE xrev=trev))"
                  " WHEN (SELECT xpref FROM x WHERE xrev=trev)"
                  "  THEN substr(tpath,(SELECT xlen FROM x WHERE xrev=trev)+1)"
                  " END;"
                  "DELETE FROM xfiles WHERE tpath ISNULL");
  }else{
    db_multi_exec("UPDATE xrevisions SET tparent=trev-1");
  }
  db_prepare(&qRev, "SELECT trev, tuser, tmsg, ttime, tparent, tbranch"
                    " FROM xrevisions "
                    " ORDER BY trev");

  db_prepare(&qParent, "SELECT tuuid, tbranch FROM xrevisions WHERE trev=:rev");

  db_prepare(&qFiles, "SELECT tpath, uuid, tperm"
                      " FROM xfiles JOIN blob ON xfiles.trid=blob.rid"
                      " WHERE trev=:rev ORDER BY tpath");
  db_prepare(&qTags, "SELECT ttag FROM xtags WHERE trev=:rev");














  db_prepare(&setUuid, "UPDATE xrevisions"
                       " SET tuuid=(SELECT uuid FROM blob WHERE rid=:rid)"
                       " WHERE trev=:rev");

  blob_zero(&manifest);
  while( db_step(&qRev)==SQLITE_ROW ){
    int rev = db_column_int(&qRev, 0);
    const char *zUser = db_column_text(&qRev, 1);
    const char *zMsg = db_column_text(&qRev, 2);
    const char *zTime = db_column_text(&qRev, 3);
    int parentRev = db_column_int(&qRev, 4);
    const char *zBranch = db_column_text(&qRev, 5);
    int rid;
    const char *zParentBranch = 0;
    Blob mcksum;
    blob_reset(&manifest);
    if( zMsg ){
      blob_appendf(&manifest, "C %F\n", zMsg);
    }else{
      blob_append(&manifest, "C (no\\scomment)\n", 16);
    }
    blob_appendf(&manifest, "D %s\n", zTime);







    db_bind_int(&qFiles, ":rev", rev);
    while( db_step(&qFiles)==SQLITE_ROW ){
      const char *zFile = db_column_text(&qFiles, 0);
      const char *zUuid = db_column_text(&qFiles, 1);
      const char *zPerm = db_column_text(&qFiles, 2);


      blob_appendf(&manifest, "F %F %s %s\n", zFile, zUuid, zPerm);

    }
    db_reset(&qFiles);
    if( parentRev>=0 ){
      const char *zParentUuid;
      db_bind_int(&qParent, ":rev", parentRev);
      db_step(&qParent);
      zParentUuid = db_column_text(&qParent, 0);
      blob_appendf(&manifest, "P %s\n", zParentUuid);
      if( !flatFlag ){
        zParentBranch = db_column_text(&qParent, 1);
        if( strcmp(zBranch, zParentBranch)!=0 ){
          blob_appendf(&manifest, "T *branch * %s\n", zBranch);
          blob_appendf(&manifest, "T *sym-%s *\n", zBranch);
          zParentBranch = mprintf("%s", zParentBranch);
        }else{
          zParentBranch = 0;
        }
      }
      db_reset(&qParent);
    }else{
      blob_appendf(&manifest, "T *branch * trunk\n");
      blob_appendf(&manifest, "T *sym-trunk *\n");
    }
    db_bind_int(&qTags, ":rev", 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", rev);
    if( zParentBranch ) {
      blob_appendf(&manifest, "T -sym-%s *\n", zParentBranch);
      zParentBranch = 0;
    }
    if( zUser ){
      blob_appendf(&manifest, "U %F\n", 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(&setUuid, ":rid", rid);

    db_bind_int(&setUuid, ":rev", rev);
    db_step(&setUuid);
    db_reset(&setUuid);
  }
  db_finalize(&qRev);
  db_finalize(&qParent);
  db_finalize(&qFiles);
  db_finalize(&qTags);
  db_finalize(&setUuid);
}

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

  }
}

/*
** Read the svn-dump format from pIn and insert the corresponding
** content into the database.
*/
static void svn_dump_import(FILE *pIn, int flatFlag){
  SvnRecord rec;
  int ver;
  const char *zTemp;
  const char *zUuid;
  char zBranch[200] = {0};
  Stmt insRev;
  Stmt insFile;
  Stmt insTag;
  Stmt delFile;
  Stmt setBranch;
  Stmt setParent;
  int rev = 0;

  /* 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);
    }
  }else{
    fossil_fatal("Input is not an svn-dump!");
  }
  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(&insRev,
      "INSERT INTO xrevisions (trev, tuser, tmsg, ttime) "
      "VALUES(:rev, :user, :msg, :time)"
  );
  db_prepare(&insFile,
      "INSERT INTO xfiles (trev, tpath, trid, tperm) "
      "VALUES(:rev, :path, :rid, :perm)"
  );
  db_prepare(&insTag, "INSERT INTO xtags (trev, ttag) VALUES(:rev, :tag)");
  db_prepare(&delFile,
      "DELETE FROM xfiles "

      "WHERE trev=:rev "
      "  AND (tpath=:path OR (tpath>:path||'/' AND tpath<:path||'0'))"
  );
  db_prepare(&setBranch,
      "UPDATE xrevisions SET tbranch=:branch "
      "WHERE trev=:rev"



  );
  db_prepare(&setParent,
      "UPDATE xrevisions SET tparent=:parent "
      "WHERE trev=:rev"
  );
  while( svn_read_rec(pIn, &rec) ){
    if( zTemp = svn_find_header(rec, "Revision-number") ){
      const char *zUser = svn_find_prop(rec, "svn:author");
      const char *zLog = svn_find_prop(rec, "svn:log");
      const char *zDate = svn_find_prop(rec, "svn:date");
      if( !flatFlag ){
        if( *zBranch ){


          db_bind_text(&setBranch, ":branch", zBranch);
          db_bind_int(&setBranch, ":rev", rev);
          db_step(&setBranch);
          db_reset(&setBranch);
          zBranch[0] = 0;
        }
      }
      zDate = date_in_standard_format(zDate);
      rev = atoi(zTemp);
      db_bind_int(&insRev, ":rev", rev);
      db_bind_text(&insRev, ":user", zUser);
      db_bind_text(&insRev, ":msg", zLog);
      db_bind_text(&insRev, ":time", zDate);
      db_step(&insRev);


      db_reset(&insRev);

      fossil_free(zDate);
      if( rev>0 ){
        db_multi_exec("INSERT INTO xfiles (trev, tpath, trid, tperm) "
                      "SELECT %d, tpath, trid, tperm FROM xfiles "
                      "WHERE trev=%d", rev, rev-1);
      }
    }else
    if( zTemp = svn_find_header(rec, "Node-path") ){
      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 = -1;
      int rid = 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( !flatFlag ){
        if( strncmp(zPath, "branches/", 9)==0 ){
          int i;
          sqlite3_snprintf(sizeof(zBranch), zBranch, "%s", zPath+9);

          for( i=0; zBranch[i]; i++ ){


            if( zBranch[i]=='/' ) zBranch[i]=0;
          }


        }else
        if( strncmp(zPath, "trunk/", 6)==0 ){

          memcpy(zBranch, "trunk", 6);


        }
      }
      if( strncmp(zAction, "delete", 6)==0
       || strncmp(zAction, "replace", 7)==0 )
      {
        db_bind_int(&delFile, ":rev", rev);
        db_bind_text(&delFile, ":path", zPath);

        db_step(&delFile);
        db_reset(&delFile);
      } /* 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_multi_exec(
              "INSERT INTO xfiles (trev, tpath, trid, tperm) "
              " SELECT %d, %Q||substr(tpath, length(%Q)+1), trid, tperm "
              " FROM xfiles "
              " WHERE trev=%d AND tpath GLOB '%q/*'",
              rev, zPath, zSrcPath, srcRev, zSrcPath
            );
            if( !flatFlag ){
              if( strncmp(zPath, "branches/", 9)==0 ){
                zTemp = zPath+9;
                while( *zTemp && *zTemp!='/' ){ zTemp++; }
                if( *zTemp==0 ){
                  db_bind_int(&setParent, ":parent", srcRev);
                  db_bind_int(&setParent, ":rev", rev);
                  db_step(&setParent);
                  db_reset(&setParent);
                }
              }else if( strncmp(zPath, "tags/", 5)==0 ){
                zTemp = zPath+5;
                db_bind_int(&insTag, ":rev", srcRev);
                db_bind_text(&insTag, ":tag", zTemp);
                db_step(&insTag);
                db_reset(&insTag);
              }
            }
          }
        }else{

          if( zSrcPath ){
            rid = db_int(0,
                         "SELECT trid FROM xfiles WHERE trev=%d AND tpath=%Q",
                         srcRev, zSrcPath);



          }
          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_int(&insFile, ":rev", rev);
          db_bind_int(&insFile, ":rid", rid);
          db_bind_text(&insFile, ":path", zPath);
          db_bind_text(&insFile, ":perm", zPerm);
          db_step(&insFile);
          db_reset(&insFile);
        }
      }else
      if( strncmp(zAction, "change", 6)==0 ){

        if( zKind==0 ){
          fossil_fatal("Missing Node-kind");
        }
        if( strncmp(zKind, "dir", 3)==0 ) continue;
        if( deltaFlag ){
          Blob deltaSrc;
          Blob target;
          rid = db_int(0, "SELECT trid FROM xfiles WHERE tpath=%Q AND trev=%d",
                       zPath, rev-1);
          content_get(rid, &deltaSrc);
          svn_apply_svndiff(&rec.content, &deltaSrc, &target);
          rid = content_put(&target);
        }else{
          rid = content_put(&rec.content);
        }
        db_bind_int(&insFile, ":rev", rev);
        db_bind_int(&insFile, ":rid", rid);
        db_bind_text(&insFile, ":path", zPath);
        db_bind_text(&insFile, ":perm", zPerm);
        db_step(&insFile);
        db_reset(&insFile);
      }else
      if( strncmp(zAction, "delete", 6)==0){ /* already did this above */
      }else{
        fossil_fatal("Unknown Node-action");
      }
    }else{
      fossil_fatal("Unknown record type");
    }
    svn_free_rec(&rec);
  }
  if( !flatFlag ){
    if( *zBranch ){
      db_bind_text(&setBranch, ":branch", zBranch);
      db_bind_int(&setBranch, ":rev", rev);
      db_step(&setBranch);
    }
  }



  db_finalize(&insRev);
  db_finalize(&insFile);
  db_finalize(&insTag);
  db_finalize(&delFile);
  db_finalize(&setBranch);
  db_finalize(&setParent);
  svn_create_manifests(flatFlag);

}

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

*/
void import_cmd(void){
  char *zPassword;
  FILE *pIn;
  Stmt q;
  int forceFlag = find_option("force", "f", 0)!=0;
  int incrFlag = find_option("incremental", "i", 0)!=0;
  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 PRIMARY KEY, tuser TEXT, tmsg TEXT, ttime DATETIME,"


       " tparent INT, tbranch TEXT, tuuid TEXT"

       ");"
       "CREATE TEMP TABLE xfiles("
       " trev INT, tpath TEXT, trid TEXT, tperm TEXT,"
       " UNIQUE (trev, tpath) ON CONFLICT REPLACE"
       ");"






       "CREATE TEMP TABLE xtags("
       " trev INT, ttag TEXT"
       ");"
    );
    svn_dump_import(pIn, flatFlag);
  }


  db_end_transaction(0);
  db_begin_transaction();
  fossil_print("Rebuilding repository meta-data...\n");
  rebuild_db(0, 1, !incrFlag);
  verify_cancel();
  db_end_transaction(0);
  fossil_print("Vacuuming..."); fflush(stdout);