/**
   The elipsis counterpart of fsl_stmt_bind_fmtv().
*/
FSL_EXPORT int fsl_stmt_bind_fmt( fsl_stmt * const st, char const * fmt, ... );

/**
    Binds a series of values using a formatting string.

    The string may contain the following characters, each of which
    refers to the next argument in the args list:

    '-': binds a NULL and expects a NULL placeholder
    in the argument list (for consistency's sake).

    'i': binds an int32

    'I': binds an int64

    'R': binds a fsl_id_t ('R' as in 'RID')

    'f': binds a double

    's': binds a (char const *) as text or NULL.

    'S': binds a (char const *) as a blob or NULL.

    'b': binds a (fsl_buffer const *) as text or NULL.

    'B': binds a (fsl_buffer const *) as a blob or NULL.

    ' ': spaces are allowed for readability and are ignored.

    Returns 0 on success, any number of other FSL_RC_xxx codes on
    error.

    ACHTUNG: the "sSbB" bindings assume, because of how this API is
    normally used, that the memory pointed to by the given argument

                       "SELECT 1 FROM tagxref"
                       " WHERE tagid=%d AND rid=%"FSL_ID_T_PFMT
                       " AND tagtype>0"
                       " AND value=%Q",
                       FSL_TAGID_BRANCH, vid, name);
}

/**
   Interal helper for fsl_checkin_commit().

   Update vfile.isexe and vfile.islink to match d's F-cards. We should
   arguably do this while calculating the F-cards, as that would not
   require iterating over d's F-cards again, but having it here is
   currently simpler (and incidentally matches how fossil(1) does it).
*/
static int fsl__commit_update_exelink( fsl_cx * const f,
                                       fsl_db * const dbC,
                                       fsl_deck * const d ) {
  int rc = 0;
  fsl_stmt q = fsl_stmt_empty;
  fsl_card_F const * pFile = NULL;
  assert( dbC );
  assert( d->rid );
  /*
    For reference's sake, the fossil(1) counterpart code:

    // Update the isexe and islink columns of the vfile table
    db_prepare(&q,
      "UPDATE vfile SET isexe=:exec, islink=:link"
      " WHERE vid=:vid AND pathname=:path AND (isexe!=:exec OR islink!=:link)"
    );
    db_bind_int(&q, ":vid", nvid);
    pManifest = manifest_get(nvid, CFTYPE_MANIFEST, 0);
    manifest_file_rewind(pManifest);
    while( (pFile = manifest_file_next(pManifest, 0)) ){
      db_bind_int(&q, ":exec", pFile->zPerm && strstr(pFile->zPerm, "x"));
      db_bind_int(&q, ":link", pFile->zPerm && strstr(pFile->zPerm, "l"));
      db_bind_text(&q, ":path", pFile->zName);
      db_step(&q);
      db_reset(&q);
    }
    db_finalize(&q);
  */
  rc = fsl_db_prepare(
    dbC, &q,
    "UPDATE vfile SET isexe=?1, islink=?2 "
    "WHERE vid=?4 AND pathname=?3 AND (isexe!=?1 OR islink!=?2)"
    /* yes, ?4 and ?3 are intentionally out of order to simplify
       code below */
  );
  if(rc){
    fsl_cx_uplift_db_error(f, dbC);
    return rc;
  }
  fsl_stmt_bind_id(&q, 4, d->rid);
  rc = fsl_deck_F_rewind(d);
  while( 0==rc ){
    rc = fsl_deck_F_next(d, &pFile);
    if(rc || !pFile) break;
    rc = fsl_stmt_bind_fmt(
      &q, "iis",
      FSL_FILE_PERM_EXE==pFile->perm,
      FSL_FILE_PERM_LINK==pFile->perm,
      pFile->name
    );
    if(0==rc){
      if( FSL_RC_STEP_DONE==(rc = fsl_stmt_step(&q)) ){
        rc = 0;
      }
    }
    fsl_stmt_reset(&q);
  }
  fsl_stmt_finalize(&q);
  return rc;
}/* vfile.isexe/islink updates */

int fsl_checkin_commit(fsl_cx * f, fsl_checkin_opt const * opt,
                       fsl_id_t * newRid, fsl_uuid_str * newUuid ){
  int rc;
  fsl_deck deck = fsl_deck_empty;
  fsl_deck *d = &deck;
  fsl_db * dbC;
  fsl_db * dbR;

  if(!rc) rc = fsl__ckout_version_write(f, d->rid, NULL);
  RC;
  assert(d->f == f);
  rc = fsl_checkin_add_unsent(f, d->rid);
  RC;
  rc = fsl__ckout_clear_merge_state(f, true);
  RC;
  rc = fsl__commit_update_exelink(f, dbC, d);
  RC;
  /*
    todo(?) from fossil(1) follows. Most of this seems to be what the
    vfile handling does (above).

    db_multi_exec("PRAGMA %s.application_id=252006673;", db_name("repository"));
    db_multi_exec("PRAGMA %s.application_id=252006674;", db_name("localdb"));

    // Update the vfile and vmerge tables
    db_multi_exec(
      "DELETE FROM vfile WHERE (vid!=%d OR deleted) AND is_selected(id);"
      "DELETE FROM vmerge;"
      "UPDATE vfile SET vid=%d;"
      "UPDATE vfile SET rid=mrid, chnged=0, deleted=0, origname=NULL"
      " WHERE is_selected(id);"
      , vid, nvid
    );
    db_lset_int("checkout", nvid);


















  */

  if(opt->dumpManifestFile){
    FILE * out;
    /* MARKER(("Dumping generated manifest to file [%s]:\n", opt->dumpManifestFile)); */
    out = fsl_fopen(opt->dumpManifestFile, "w");
    if(out){

  if(rc && !f->error.code){
    if(f->dbMain->error.code) fsl_cx_uplift_db_error(f, f->dbMain);
    else f->error.code = rc;
  }
  fsl_checkin_discard(f);
  fsl_deck_finalize(d);
  return rc;
}/*fsl_checkin_commit()*/


#undef MARKER

    while( !rc && !(rc=fsl_deck_F_next(d, &fc)) && fc) {
      rc = cb( fc, visitorState );
    }
    return (FSL_RC_BREAK==rc) ? 0 : rc;
  }
}


/**
    Output state for fsl_output_f_mf() and friends. Used for managing
    the output of a fsl_deck.
 */
struct fsl_deck_out_state {
  /**
      The set of cards being output. We use this to delegate certain

  }
  rc = fsl_deck_unshuffle(d,
                          (FSL_CX_F_CALC_R_CARD & f->flags)
                          ? ((d->F.used && !d->R) ? 1 : 0)
                          : 0);
  /* ^^^^ unshuffling might install an R-card, so we have to
     do that before checking whether all required cards are
     set... */
  if( !rc ) rc = fsl_deck_F_rewind(d);
  if(rc) return rc;
  else if(!fsl_deck_has_required_cards(d)){
    return FSL_RC_SYNTAX;
  }

  os->d = d;
  os->out = out;

                               isPrimary, pParentFile->perm);
      }
    }
    if(rc) goto end;
  }

  fsl__cx_mcache_insert(f, &dOther);

  /* If pParent is the primary parent of pChild, also run this analysis
  ** for all merge parents of pChild */
  if( pmid && isPrimary ){
    for(i=1; i<pChild->P.used; i++){
      pmid = fsl_uuid_to_rid(f, (char const*)pChild->P.list[i]);
      if( pmid<=0 ) continue;
      rc = fsl_mlink_add(f, pmid, 0, cid, pChild, false);