Fossil

** Do a diff against a single file named in g.argv[2] from version zFrom
** against the same file on disk.
*/
static void diff_one_against_disk(const char *zFrom, const char *zDiffCmd){
  Blob fname;
  Blob content;
  file_tree_name(g.argv[2], &fname, 1);
  historical_version_of_file(zFrom, blob_str(&fname), &content);
  diff_file(&content, g.argv[2], g.argv[2], zDiffCmd);
  blob_reset(&content);
  blob_reset(&fname);
}

/*
** Run a diff between the version zFrom and files on disk.  zFrom might

  const char *zDiffCmd
){
  char *zName;
  Blob fname;
  Blob v1, v2;
  file_tree_name(g.argv[2], &fname, 1);
  zName = blob_str(&fname);
  historical_version_of_file(zFrom, zName, &v1);
  historical_version_of_file(zTo, zName, &v2);
  diff_file_mem(&v1, &v2, zName, zDiffCmd);
  blob_reset(&v1);
  blob_reset(&v2);
  blob_reset(&fname);
}

/*

}

/*
** COMMAND: undo
**
** Usage: %fossil undo ?FILENAME...?
**
** Undo the most recent update or merge operation.  If FILENAME is
** specified then restore the content of the named file(s) but otherwise
** leave the update or merge in effect.
**
** A single level of undo/redo is supported.  The undo/redo stack
** is cleared by the commit and checkout commands.
*/
void undo_cmd(void){
  int undo_available;
  db_must_be_within_tree();

}

/*
** COMMAND: redo
**
** Usage: %fossil redo ?FILENAME...?
**
** Redo the an update or merge operation that has been undone by the
** undo command.  If FILENAME is specified then restore the changes
** associated with the named file(s) but otherwise leave the update
** or merge undone.
**
** A single level of undo/redo is supported.  The undo/redo stack
** is cleared by the commit and checkout commands.
*/
void redo_cmd(void){

/*
** Get the contents of a file within a given revision.
*/
int historical_version_of_file(
  const char *revision,    /* The baseline name containing the file */
  const char *file,        /* Full treename of the file */
  Blob *content            /* Put the content here */

){
  Blob mfile;
  Manifest m;
  int i, rid=0;
  
  if( revision ){
    rid = name_to_rid(revision);
  }else{
    rid = db_lget_int("checkout", 0);
  }
  if( !is_a_version(rid) ){

    fossil_fatal("no such check-out: %s", revision);
  }
  content_get(rid, &mfile);
  
  if( manifest_parse(&m, &mfile) ){
    for(i=0; i<m.nFile; i++){
      if( strcmp(m.aFile[i].zName, file)==0 ){
        rid = uuid_to_rid(m.aFile[i].zUuid, 0);
        return content_get(rid, content);
      }
    }

    fossil_fatal("file %s does not exist in baseline: %s", file, revision);

  }else{
    fossil_panic("could not parse manifest for baseline: %s", revision);
  }
  return 0;
}


/*
** COMMAND: revert
**
** Usage: %fossil revert ?--yes? ?-r REVISION? FILE ...
**
** Revert to the current repository version of FILE, or to
** the version associated with baseline REVISION if the -r flag
** appears.  This command will confirm your operation unless the
** file is missing or the --yes option is used.
**/



void revert_cmd(void){
  char *zFile;
  const char *zRevision;
  Blob fname;
  Blob record;
  Blob ans;
  int i;

  int rid = 0;
  int yesFlag;
  int yesRevert;
  
  yesFlag = find_option("yes", "y", 0)!=0;
  zRevision = find_option("revision", "r", 1);
  verify_all_options();
  
  if( g.argc<3 ){
    usage("?OPTIONS FILE ...");
  }
  db_must_be_within_tree();



  for(i=2; i<g.argc; i++){
    zFile = mprintf("%/", g.argv[i]);
    file_tree_name(zFile, &fname, 1);
    yesRevert = yesFlag;
    if( !yesRevert && access(zFile, 0) ) yesRevert = 1;  
    if( yesRevert==0 ){
      char *prompt = mprintf("revert file %B? this will"
                             " destroy local changes (y/N)? ",
                             &fname);
      blob_zero(&ans);
      prompt_user(prompt, &ans);
      free( prompt );
      if( blob_str(&ans)[0]=='y' ){
        yesRevert = 1;
      }
      blob_reset(&ans);
    }

    if( yesRevert==1 && zRevision!=0 ){
      historical_version_of_file(zRevision, zFile, &record);

    }else if( yesRevert==1 ){
      rid = db_int(0, "SELECT rid FROM vfile WHERE pathname=%B", &fname);
      if( rid==0 ){
        fossil_panic("no history for file: %b", &fname);

      }
      content_get(rid, &record);

    }
  
    if( yesRevert==1 ){




      blob_write_to_file(&record, zFile);
      printf("%s reverted\n", zFile);

      blob_reset(&record);
      blob_reset(&fname);
    }else{
      printf("revert canceled\n");
    }
    free(zFile);
  }

}