/* Possible names of auxiliary files generated when the "manifest" property
  ** is used
  */
  static const struct {
    const char *fname;
    int flg;
  }aManifestflags[] = {
    { "manifest",          MFESTFLG_RAW },
    { "manifest.uuid",     MFESTFLG_UUID },
    { "manifest.tags",     MFESTFLG_TAGS },
    { "manifest.symlinks", MFESTFLG_SYMLINKS }
  };
  static const char *azManifests[4];

  /*
  ** Names of repository files, if they exist in the checkout.
  */
  static const char *azRepo[4] = { 0, 0, 0, 0 };

  /* Cached setting "manifest" */

    zManifestFile = mprintf("%smanifest.tags", g.zLocalRoot);
    blob_zero(&tagslist);
    get_checkin_taglist(nvid, &tagslist);
    blob_write_to_file(&tagslist, zManifestFile);
    blob_reset(&tagslist);
    free(zManifestFile);
  }

  if( outputManifest & MFESTFLG_SYMLINKS ){
    Blob symlinkslist;
    zManifestFile = mprintf("%smanifest.symlinks", g.zLocalRoot);
    blob_zero(&symlinkslist);
    get_checkin_symlinklist(nvid, &symlinkslist);
    blob_write_to_file(&symlinkslist, zManifestFile);
    blob_reset(&symlinkslist);
    free(zManifestFile);
  }

  if( !g.markPrivate ){
    autosync_loop(SYNC_PUSH|SYNC_PULL, db_get_int("autosync-tries", 1), 0);
  }
  if( count_nonbranch_children(vid)>1 ){
    fossil_print("**** warning: a fork has occurred *****\n");
  }

  db_bind_text(&s, ":path", zFilename);
  db_step(&s);
  db_reset(&s);
}

/*
** Set or clear the execute permission bit (as appropriate) for all
** files in the current check-out.

*/
void checkout_set_all_exe(int vid){
  Blob filename;
  int baseLen;
  Manifest *pManifest;
  ManifestFile *pFile;

/*
** If the "manifest" setting is true, then automatically generate
** files named "manifest" and "manifest.uuid" containing, respectively,
** the text of the manifest and the artifact ID of the manifest.
** If the manifest setting is set, but is not a boolean value, then treat
** each character as a flag to enable writing "manifest", "manifest.uuid",
** "manifest.tags", or "manifest.symlinks".
*/
void manifest_to_disk(int vid){
  char *zManFile;
  Blob manifest;
  Blob taglist;
  Blob symlinklist;
  int flg;

  flg = db_get_manifest_setting();

  if( flg & MFESTFLG_RAW ){
    blob_zero(&manifest);
    content_get(vid, &manifest);

  }else{
    if( !db_exists("SELECT 1 FROM vfile WHERE pathname='manifest.tags'") ){
      zManFile = mprintf("%smanifest.tags", g.zLocalRoot);
      file_delete(zManFile);
      free(zManFile);
    }
  }
  if( flg & MFESTFLG_SYMLINKS ){
    blob_zero(&symlinklist);
    zManFile = mprintf("%smanifest.symlinks", g.zLocalRoot);
    get_checkin_symlinklist(vid, &symlinklist);
    blob_write_to_file(&symlinklist, zManFile);
    free(zManFile);
    blob_reset(&symlinklist);
  }else{
    if( !db_exists("SELECT 1 FROM vfile WHERE pathname='manifest.symlinks'") ){
      zManFile = mprintf("%smanifest.symlinks", g.zLocalRoot);
      file_delete(zManFile);
      free(zManFile);
    }
  }
}

/*
** Find the branch name and all symbolic tags for a particular check-in
** identified by "rid".
**
** The branch name is actually only extracted if this procedure is run

    zName = db_column_text(&stmt, 0);
    blob_appendf(pOut, "tag %s\n", zName);
  }
  db_reset(&stmt);
  db_finalize(&stmt);
}

/*
** Store into "pOut" a sorted list of all symlinks in a checkin "rid".  Each
** entry in the list is the full name of the symlink (not the name of its
** target) followed by a newline.
*/
void get_checkin_symlinklist(int rid, Blob *pOut){
  Manifest *pManifest = manifest_get(rid, CFTYPE_MANIFEST, 0);
  ManifestFile *pFile;
  blob_reset(pOut);
  manifest_file_rewind(pManifest);
  while( (pFile = manifest_file_next(pManifest, 0)) ){
    if( pFile->zPerm && strstr(pFile->zPerm, "l") ){
      blob_appendf(pOut, "%s\n", pFile->zName);
    }
  }
  manifest_destroy(pManifest);
}

/*
** COMMAND: checkout*
** COMMAND: co*
**
** Usage: %fossil checkout ?VERSION | --latest? ?OPTIONS?
**    or: %fossil co ?VERSION | --latest? ?OPTIONS?

}
void db_lset_int(const char *zName, int value){
  db_multi_exec("REPLACE INTO vvar(name,value) VALUES(%Q,%d)", zName, value);
}

#if INTERFACE
/* Manifest generation flags */
#define MFESTFLG_RAW      0x01
#define MFESTFLG_UUID     0x02
#define MFESTFLG_TAGS     0x04
#define MFESTFLG_SYMLINKS 0x08
#endif /* INTERFACE */

/*
** Get the manifest setting.  For backwards compatibility first check if the
** value is a boolean.  If it's not a boolean, treat each character as a flag
** to enable a manifest type.  This system puts certain boundary conditions on
** which letters can be used to represent flags (any permutation of flags must
** not be able to fully form one of the boolean values).
*/
int db_get_manifest_setting(void){
  int flg;
  char *zVal = db_get("manifest", 0);
  if( zVal==0 || is_false(zVal) ){
    return 0;
  }else if( is_truth(zVal) ){
    return MFESTFLG_RAW|MFESTFLG_UUID;
  }
  flg = 0;
  while( *zVal ){
    switch( *zVal ){
      case 'r': flg |= MFESTFLG_RAW;      break;
      case 'u': flg |= MFESTFLG_UUID;     break;
      case 't': flg |= MFESTFLG_TAGS;     break;
      case 'l': flg |= MFESTFLG_SYMLINKS; break;
    }
    zVal++;
  }
  return flg;
}

** The value is the primary branch for the project.
*/
/*
** SETTING: manifest         width=5 versionable
** If enabled, automatically create files "manifest" and "manifest.uuid"
** in every checkout.
**
** Optionally use combinations of characters 'r' for "manifest", 'u' for
** "manifest.uuid", 't' for "manifest.tags", and 'l' for "manifest.symlinks".
** The SQLite and Fossil repositories both require manifests.
*/
/*
** SETTING: max-loadavg      width=25 default=0.0
** Some CPU-intensive web pages (ex: /zip, /tarball, /blame)
** are disallowed if the system load average goes above this
** value.  "0.0" means no limit.  This only works on unix.
** Only local settings of this value make a difference since

        eflg |= MFESTFLG_UUID;
      }
      if( (pInclude==0 || glob_match(pInclude, "manifest.tags"))
       && !glob_match(pExclude, "manifest.tags")
       && (flg & MFESTFLG_TAGS) ){
        eflg |= MFESTFLG_TAGS;
      }
      if( (pInclude==0 || glob_match(pInclude, "manifest.symlinks"))
       && !glob_match(pExclude, "manifest.symlinks")
       && (flg & MFESTFLG_SYMLINKS) ){
        eflg |= MFESTFLG_SYMLINKS;
      }

      if( eflg & (MFESTFLG_RAW|MFESTFLG_UUID) ){
        if( eflg & MFESTFLG_RAW ){
          blob_append(&filename, "manifest", -1);
          zName = blob_str(&filename);
        }
        if( eflg & MFESTFLG_RAW ) {

        blob_zero(&tagslist);
        get_checkin_taglist(rid, &tagslist);
        blob_resize(&filename, nPrefix);
        blob_append(&filename, "manifest.tags", -1);
        zName = blob_str(&filename);
        tar_add_file(zName, &tagslist, 0, mTime);
        blob_reset(&tagslist);
      }
      if( eflg & MFESTFLG_SYMLINKS ){
        Blob symlinklist;
        blob_zero(&symlinklist);
        get_checkin_symlinklist(rid, &symlinklist);
        blob_resize(&filename, nPrefix);
        blob_append(&filename, "manifest.symlinks", -1);
        zName = blob_str(&filename);
        tar_add_file(zName, &symlinklist, 0, mTime);
        blob_reset(&symlinklist);
      }
    }
    manifest_file_rewind(pManifest);
    while( (pFile = manifest_file_next(pManifest,0))!=0 ){
      int fid;
      if( pInclude!=0 && !glob_match(pInclude, pFile->zName) ) continue;
      if( glob_match(pExclude, pFile->zName) ) continue;

        eflg |= MFESTFLG_UUID;
      }
      if( (pInclude==0 || glob_match(pInclude, "manifest.tags"))
       && !glob_match(pExclude, "manifest.tags")
       && (flg & MFESTFLG_TAGS) ){
        eflg |= MFESTFLG_TAGS;
      }
      if( (pInclude==0 || glob_match(pInclude, "manifest.symlinks"))
       && !glob_match(pExclude, "manifest.symlinks")
       && (flg & MFESTFLG_SYMLINKS) ){
        eflg |= MFESTFLG_SYMLINKS;
      }

      if( eflg & MFESTFLG_RAW ){
        blob_append(&filename, "manifest", -1);
        zName = blob_str(&filename);
        zip_add_folders(zName);
        sterilize_manifest(&mfile);
        zip_add_file(zName, &mfile, 0);

        get_checkin_taglist(rid, &tagslist);
        blob_resize(&filename, nPrefix);
        blob_append(&filename, "manifest.tags", -1);
        zName = blob_str(&filename);
        zip_add_folders(zName);
        zip_add_file(zName, &tagslist, 0);
        blob_reset(&tagslist);
      }
      if( eflg & MFESTFLG_SYMLINKS ){
        Blob symlinklist;
        blob_zero(&symlinklist);
        get_checkin_symlinklist(rid, &symlinklist);
        blob_resize(&filename, nPrefix);
        blob_append(&filename, "manifest.symlinks", -1);
        zName = blob_str(&filename);
        zip_add_folders(zName);
        zip_add_file(zName, &symlinklist, 0);
        blob_reset(&symlinklist);
      }
    }
    manifest_file_rewind(pManifest);
    while( (pFile = manifest_file_next(pManifest,0))!=0 ){
      int fid;
      if( pInclude!=0 && !glob_match(pInclude, pFile->zName) ) continue;
      if( glob_match(pExclude, pFile->zName) ) continue;

  *  Correct the [/help?cmd=/doc|/doc] page to support read-only repositories.
  *  Correct [/help?cmd=/zip|/zip], [/help?cmd=/tarball|/tarball],
     [/help?cmd=zip|zip], and [/help?cmd=tarball|tarball] pages and commands to
     honor the versioned manifest setting when outside of an open checkout
     directory.
  *  The admin-log and access-log settings are now on by default for
     new repositories.
  *  Add support for the "l" flag to the "manifest" setting to enable creation
     of a file "manifest.symlinks" which lists the names of all symlinks.
  *  Update the built-in SQLite to version 3.20.1.

<a name='v2_3'></a>
<h2>Changes for Version 2.3 (2017-07-21)</h2>

  *  Update the built-in SQLite to version 3.20.0 (beta).
  *  Update internal Unicode character tables, used in regular expression