Fossil

          diffFiles[0].zName[0] = '.';
          diffFiles[0].zName[1] = 0;
          break;
        }
        diffFiles[i].nName = strlen(diffFiles[i].zName);
        diffFiles[i].nUsed = 0;
      }
      diff_against_disk(0, 0, 0, diff_get_binary_glob(),
                        db_get_boolean("diff-binary", 1),
                        DIFF_VERBOSE, diffFiles, &prompt);
      for( i=0; diffFiles[i].zName; ++i ){
        fossil_free(diffFiles[i].zName);
      }
      fossil_free(diffFiles);
    }else{
      diff_against_disk(0, 0, 0, diff_get_binary_glob(),
                        db_get_boolean("diff-binary", 1),
                        DIFF_VERBOSE, 0, &prompt);
    }
  }
  prompt_for_user_comment(pComment, &prompt);
  blob_reset(&prompt);
}

    if( zDefault==0 && pSetting && pSetting->def[0] ){
      z = fossil_strdup(pSetting->def);
    }else{
      z = fossil_strdup(zDefault);
    }
  }
  return z;
}
const char ** db_get_array(size_t *pnValues, const char *zName, const char* zDefault){
  const char *value = db_get(zName, zDefault ? zDefault : "[]");
  if( value[0]=='[' && value[strlen(value)-1]==']' ){
    return json_deserialize_array(pnValues, value);
  }else{
    const char** azValues = fossil_malloc(sizeof(char*)*2);
    azValues[0] = value;
    azValues[1] = 0;
    return azValues;
  }
}
char *db_get_mtime(const char *zName, const char *zFormat, const char *zDefault){
  char *z = 0;
  if( g.repositoryOpen ){
    z = db_text(0, "SELECT mtime FROM config WHERE name=%Q", zName);
  }
  if( z==0 ){

**
** The difference is the set of edits needed to transform pFile1 into
** zFile2.  The content of pFile1 is in memory.  zFile2 exists on disk.
**
** If fSwapDiff is 1, show the set of edits to transform zFile2 into pFile1
** instead of the opposite.
**
** Use the internal diff logic if nDiffCmdValues is 0.  Otherwise pass the
** command and args in azDiffCmd along with a pair of file names to
** fossil_spawn() to do the diffing externally.
**
** When using an external diff program, zBinGlob contains the GLOB patterns
** for file names to treat as binary.  If fIncludeBinary is zero, these files
** will be skipped in addition to files that may contain binary content.
*/
void diff_file(
  Blob *pFile1,             /* In memory content to compare from */
  int isBin1,               /* Does the 'from' content appear to be binary */
  const char *zFile2,       /* On disk content to compare to */
  const char *zName,        /* Display name of the file */
  const char *azDiffCmd[],  /* External diff cmd and optional args */
  size_t nDiffCmdValues,    /* Elements in azDiffCmd; 0 for internal */
  const char *zBinGlob,     /* Treat file names matching this as binary */
  int fIncludeBinary,       /* Include binary files for external diff */
  u64 diffFlags,            /* Flags to control the diff */
  int fSwapDiff,            /* Diff from Zfile2 to Pfile1 */
  Blob *diffBlob            /* Blob to store diff output */
){
  if( nDiffCmdValues==0 ){
    Blob out;                 /* Diff output text */
    Blob file2;               /* Content of zFile2 */
    const char *zName2;       /* Name of zFile2 for display */

    /* Read content of zFile2 into memory */
    blob_zero(&file2);
    if( file_size(zFile2, ExtFILE)<0 ){

      }
      blob_reset(&out);
    }

    /* Release memory resources */
    blob_reset(&file2);
  }else{
    size_t n;
    const char **azFullDiffCmd;
    Blob nameFile1;    /* Name of temporary file to old pFile1 content */


    if( !fIncludeBinary ){
      Blob file2;
      if( isBin1 ){
        fossil_print("%s",DIFF_CANNOT_COMPUTE_BINARY);
        return;
      }

    }

    /* Construct a temporary file to hold pFile1 based on the name of
    ** zFile2 */
    file_tempname(&nameFile1, zFile2, "orig");
    blob_write_to_file(pFile1, blob_str(&nameFile1));

    if( nDiffCmdValues==1 ) {
      /* With only one element in the command array, take the legacy
       * path, constructing a shell command string to do the external
       * diff.  This works for many cases, but because of the risk
       * of double shell interpretation of quotes, spaces, escape
       * characters, and such, we have to run this command string
       * through a number of prophylactic wrappers around system(3)
       * which can cause problems, as when doing diffs on file names
       * that legitimately contain spaces, quotes, etc.
       */
      Blob cmd;          /* Text of command to run */
      blob_zero(&cmd);
      blob_append(&cmd, azDiffCmd[0], -1);
      if( fSwapDiff ){
        blob_append_escaped_arg(&cmd, zFile2);
        blob_append_escaped_arg(&cmd, blob_str(&nameFile1));
      }else{
        blob_append_escaped_arg(&cmd, blob_str(&nameFile1));
        blob_append_escaped_arg(&cmd, zFile2);
      }

      /* Run the external diff command */
      fossil_system(blob_str(&cmd));
    }else{
      /* Construct an argv style array to do the external diff.
       *
       * This may look more complex, but it bypasses all of the
       * stuff we have to wrap around system(3) because we get a
       * direct binding of our argv[] to the callee's main(argv)
       * on POSIX systems, entirely avoiding the class of double
       * shell interpretation risks.  (Windows's API flattens argv,
       * neutering some of this mechanism's benefits, but not all.)
       *
       * Due to the legacy of existing settings, we can't assume
       * it's safe to take this path when the setting is a single
       * string value, since that gets converted to a 1-element
       * array by db_get_array().  Fortunately, most diff type
       * programs offer and benefit from option flags, so you
       * should be able to upgrade to this method by re-applying
       * your settings, making use of the new array storage option:
       *
       *     $ fossil set diff-command colordiff -wu
       *
       * as opposed to the legacy method:
       *
       *     $ fossil set diff-command 'colordiff -wu'
       *
       * The lack of quoting around those two setting values causes
       * Fossil to store them as an array, which lands you in here.
       */
      azFullDiffCmd = fossil_malloc((nDiffCmdValues+3)*sizeof(char*));
      for( n=0; n<nDiffCmdValues; ++n ) azFullDiffCmd[n] = azDiffCmd[n];
      if( fSwapDiff ){
        azFullDiffCmd[n++] = zFile2;
        azFullDiffCmd[n++] = blob_str(&nameFile1);
      }else{
        azFullDiffCmd[n++] = blob_str(&nameFile1);
        azFullDiffCmd[n++] = zFile2;
      }
      azFullDiffCmd[n] = 0;

      /* Run the external diff command */
      fossil_spawn(azFullDiffCmd[0], (char*const*)azFullDiffCmd);
    }

    /* Delete the temporary file and clean up memory used */
    file_delete(blob_str(&nameFile1));
    blob_reset(&nameFile1);

  }
}

/*
** Show the difference between two files, both in memory.
**
** The difference is the set of edits needed to transform pFile1 into
** pFile2.
**
** Use the internal diff logic if nDiffCmdValues is 0.  Otherwise pass the
** command and args in azDiffCmd along with a pair of file names to
** fossil_spawn() to do the diffing externally.
**
** When using an external diff program, zBinGlob contains the GLOB patterns
** for file names to treat as binary.  If fIncludeBinary is zero, these files
** will be skipped in addition to files that may contain binary content.
*/
void diff_file_mem(
  Blob *pFile1,             /* In memory content to compare from */
  Blob *pFile2,             /* In memory content to compare to */
  int isBin1,               /* Does the 'from' content appear to be binary */
  int isBin2,               /* Does the 'to' content appear to be binary */
  const char *zName,        /* Display name of the file */
  const char *azDiffCmd[],  /* External diff cmd and optional args */
  size_t nDiffCmdValues,    /* Elements in azDiffCmd; 0 for internal */
  const char *zBinGlob,     /* Treat file names matching this as binary */
  int fIncludeBinary,       /* Include binary files for external diff */
  u64 diffFlags             /* Diff flags */
){
  if( diffFlags & DIFF_BRIEF ) return;
  if( nDiffCmdValues==0 ){
    Blob out;      /* Diff output text */

    blob_zero(&out);
    text_diff(pFile1, pFile2, &out, 0, diffFlags);
    if( diffFlags & DIFF_NUMSTAT ){
      fossil_print("%s %s\n", blob_str(&out), zName);
    }else{
      diff_print_filenames(zName, zName, diffFlags, 0);
      fossil_print("%s\n", blob_str(&out));
    }

    /* Release memory resources */
    blob_reset(&out);
  }else{
    size_t n;
    const char** azFullDiffCmd;
    Blob temp1;
    Blob temp2;

    if( !fIncludeBinary ){
      if( isBin1 || isBin2 ){
        fossil_print("%s",DIFF_CANNOT_COMPUTE_BINARY);
        return;

    /* Construct a temporary file names */
    file_tempname(&temp1, zName, "before");
    file_tempname(&temp2, zName, "after");
    blob_write_to_file(pFile1, blob_str(&temp1));
    blob_write_to_file(pFile2, blob_str(&temp2));

    if( nDiffCmdValues==1 ) {
      /* Legacy system(3) wrapper method; see diff_file for details. */
      Blob cmd;          /* Text of command to run */
      blob_zero(&cmd);
      blob_append(&cmd, azDiffCmd[0], -1);
      blob_append_escaped_arg(&cmd, blob_str(&temp1));
      blob_append_escaped_arg(&cmd, blob_str(&temp2));

      /* Run the external diff command */
      fossil_system(blob_str(&cmd));
    }else{
      /* Safer argv[] passing method; see diff_file for details. */
      azFullDiffCmd = fossil_malloc((nDiffCmdValues+3)*sizeof(char*));
      for( n=0; n<nDiffCmdValues; ++n ) azFullDiffCmd[n] = azDiffCmd[n];
      azFullDiffCmd[n++] = blob_str(&temp1);
      azFullDiffCmd[n++] = blob_str(&temp2);
      azFullDiffCmd[n] = 0;

      /* Run the external diff command */
      fossil_spawn(azFullDiffCmd[0], (char*const*)azFullDiffCmd);
    }

    /* Delete the temporary file and clean up memory used */
    file_delete(blob_str(&temp1));
    file_delete(blob_str(&temp2));

    blob_reset(&temp1);
    blob_reset(&temp2);

  }
}

/*
** Run a diff between the version zFrom and files on disk.  zFrom might
** be NULL which means to simply show the difference between the edited
** files on disk and the check-out on which they are based.
**
** Use the internal diff logic if nDiffCmdValues is 0.  Otherwise pass the
** command and args in azDiffCmd along with a pair of file names to
** fossil_spawn() to do the diffing externally.
**
** When using an external diff program, zBinGlob contains the GLOB patterns
** for file names to treat as binary.  If fIncludeBinary is zero, these files
** will be skipped in addition to files that may contain binary content.
*/
void diff_against_disk(
  const char *zFrom,        /* Version to difference from */
  const char *azDiffCmd[],  /* External diff cmd and optional args */
  size_t nDiffCmdValues,    /* Elements in azDiffCmd; 0 for internal */
  const char *zBinGlob,     /* Treat file names matching this as binary */
  int fIncludeBinary,       /* Treat file names matching this as binary */
  u64 diffFlags,            /* Flags controlling diff output */
  FileDirList *pFileDir,    /* Which files to diff */
  Blob *diffBlob            /* Blob to output diff instead of stdout */
){
  int vid;

      if( srcid>0 ){
        content_get(srcid, &content);
      }else{
        blob_zero(&content);
      }
      isBin = fIncludeBinary ? 0 : looks_like_binary(&content);
      diff_print_index(zPathname, diffFlags, diffBlob);
      diff_file(&content, isBin, zFullName, zPathname, azDiffCmd, nDiffCmdValues,
                zBinGlob, fIncludeBinary, diffFlags, 0, diffBlob);
      blob_reset(&content);
    }
    blob_reset(&fname);
  }
  db_finalize(&q);
  db_end_transaction(1);  /* ROLLBACK */
}

/*
** Run a diff between the undo buffer and files on disk.
**
** Use the internal diff logic if nDiffCmdValues is 0.  Otherwise pass the
** command and args in azDiffCmd along with a pair of file names to
** fossil_spawn() to do the diffing externally.
**
** When using an external diff program, zBinGlob contains the GLOB patterns
** for file names to treat as binary.  If fIncludeBinary is zero, these files
** will be skipped in addition to files that may contain binary content.
*/
static void diff_against_undo(
  const char *azDiffCmd[],  /* External diff cmd and optional args */
  size_t nDiffCmdValues,    /* Elements in azDiffCmd; 0 for internal */
  const char *zBinGlob,     /* Treat file names matching this as binary */
  int fIncludeBinary,       /* Treat file names matching this as binary */
  u64 diffFlags,            /* Flags controlling diff output */
  FileDirList *pFileDir     /* List of files and directories to diff */
){
  Stmt q;
  Blob content;
  db_prepare(&q, "SELECT pathname, content FROM undo");
  blob_init(&content, 0, 0);
  while( db_step(&q)==SQLITE_ROW ){
    char *zFullName;
    const char *zFile = (const char*)db_column_text(&q, 0);
    if( !file_dir_match(pFileDir, zFile) ) continue;
    zFullName = mprintf("%s%s", g.zLocalRoot, zFile);
    db_column_blob(&q, 1, &content);
    diff_file(&content, 0, zFullName, zFile,
              azDiffCmd, nDiffCmdValues, zBinGlob, fIncludeBinary, diffFlags, 0, 0);
    fossil_free(zFullName);
    blob_reset(&content);
  }
  db_finalize(&q);
}

/*
** Show the difference between two files identified by ManifestFile
** entries.
**
** Use the internal diff logic if nDiffCmdValues is 0.  Otherwise pass the
** command and args in azDiffCmd along with a pair of file names to
** fossil_spawn() to do the diffing externally.
**
** When using an external diff program, zBinGlob contains the GLOB patterns
** for file names to treat as binary.  If fIncludeBinary is zero, these files
** will be skipped in addition to files that may contain binary content.
*/
static void diff_manifest_entry(
  struct ManifestFile *pFrom,
  struct ManifestFile *pTo,
  const char * azDiffCmd[],
  size_t nDiffCmdValues,
  const char *zBinGlob,
  int fIncludeBinary,
  u64 diffFlags
){
  Blob f1, f2;
  int isBin1, isBin2;
  int rid;

    rid = uuid_to_rid(pTo->zUuid, 0);
    content_get(rid, &f2);
  }else{
    blob_zero(&f2);
  }
  isBin1 = fIncludeBinary ? 0 : looks_like_binary(&f1);
  isBin2 = fIncludeBinary ? 0 : looks_like_binary(&f2);
  diff_file_mem(&f1, &f2, isBin1, isBin2, zName, azDiffCmd, nDiffCmdValues,
                zBinGlob, fIncludeBinary, diffFlags);
  blob_reset(&f1);
  blob_reset(&f2);
}

/*
** Output the differences between two check-ins.
**
** Use the internal diff logic if nDiffCmdValues is 0.  Otherwise pass the
** command and args in azDiffCmd along with a pair of file names to
** fossil_spawn() to do the diffing externally.
**
** When using an external diff program, zBinGlob contains the GLOB patterns
** for file names to treat as binary.  If fIncludeBinary is zero, these files
** will be skipped in addition to files that may contain binary content.
*/
static void diff_two_versions(
  const char *zFrom,
  const char *zTo,
  const char *azDiffCmd[],
  size_t nDiffCmdValues,
  const char *zBinGlob,
  int fIncludeBinary,
  u64 diffFlags,
  FileDirList *pFileDir
){
  Manifest *pFrom, *pTo;
  ManifestFile *pFromFile, *pToFile;

    }
    if( cmp<0 ){
      if( file_dir_match(pFileDir, pFromFile->zName) ){
        if( (diffFlags & DIFF_NUMSTAT)==0 ){
          fossil_print("DELETED %s\n", pFromFile->zName);
        }
        if( asNewFlag ){
          diff_manifest_entry(pFromFile, 0, azDiffCmd, nDiffCmdValues, zBinGlob,
                              fIncludeBinary, diffFlags);
        }
      }
      pFromFile = manifest_file_next(pFrom,0);
    }else if( cmp>0 ){
      if( file_dir_match(pFileDir, pToFile->zName) ){
        if( (diffFlags & DIFF_NUMSTAT)==0 ){
          fossil_print("ADDED   %s\n", pToFile->zName);
        }
        if( asNewFlag ){
          diff_manifest_entry(0, pToFile, azDiffCmd, nDiffCmdValues, zBinGlob,
                              fIncludeBinary, diffFlags);
        }
      }
      pToFile = manifest_file_next(pTo,0);
    }else if( fossil_strcmp(pFromFile->zUuid, pToFile->zUuid)==0 ){
      /* No changes */
      (void)file_dir_match(pFileDir, pFromFile->zName); /* Record name usage */
      pFromFile = manifest_file_next(pFrom,0);
      pToFile = manifest_file_next(pTo,0);
    }else{
      if( file_dir_match(pFileDir, pToFile->zName) ){
        if( diffFlags & DIFF_BRIEF ){
          fossil_print("CHANGED %s\n", pFromFile->zName);
        }else{
          diff_manifest_entry(pFromFile, pToFile, azDiffCmd, nDiffCmdValues, zBinGlob,
                              fIncludeBinary, diffFlags);
        }
      }
      pFromFile = manifest_file_next(pFrom,0);
      pToFile = manifest_file_next(pTo,0);
    }
  }
  manifest_destroy(pFrom);
  manifest_destroy(pTo);
}

/*
** Return the name of the external diff command, or return NULL if
** no external diff command is defined.
*/
const char ** diff_command_external(size_t *pnValues, int guiDiff){
  const char *zDefault;
  const char *zName;

  if( guiDiff ){
#if defined(_WIN32)
    zDefault = "[\"WinDiff.exe\"]";
#else
    zDefault = 0;
#endif
    zName = "gdiff-command";
  }else{
    zDefault = 0;
    zName = "diff-command";
  }
  return db_get_array(pnValues, zName, zDefault);
}

/*
** Show diff output in a Tcl/Tk window, in response to the --tk option
** to the diff command.
**
** If fossil has direct access to a Tcl interpreter (either loaded

  int isGDiff;               /* True for gdiff.  False for normal diff */
  int isInternDiff;          /* True for internal diff */
  int verboseFlag;           /* True if -v or --verbose flag is used */
  const char *zFrom;         /* Source version number */
  const char *zTo;           /* Target version number */
  const char *zCheckin;      /* Check-in version number */
  const char *zBranch;       /* Branch to diff */
  const char **azDiffCmd;    /* External diff cmd and optional args */
  size_t nDiffCmdValues = 0; /* Number of elements in azDiffCmd; 0 for internal */
  const char *zBinGlob = 0;  /* Treat file names matching this as binary */
  int fIncludeBinary = 0;    /* Include binary files for external diff */
  int againstUndo = 0;       /* Diff against files in the undo buffer */
  u64 diffFlags = 0;         /* Flags to control the DIFF */
  FileDirList *pFileDir = 0; /* Restrict the diff to these files */

  if( find_option("tk",0,0)!=0 || has_option("tclsh") ){

    db_must_be_within_tree();
  }else if( zFrom==0 ){
    fossil_fatal("must use --from if --to is present");
  }else{
    db_find_and_open_repository(0, 0);
  }
  if( !isInternDiff ){
    const char *zDiffCmd = find_option("command", 0, 1);
    if( zDiffCmd ){
      azDiffCmd = malloc(2*sizeof(char*));
      azDiffCmd[0] = zDiffCmd;
      azDiffCmd[1] = 0;
      nDiffCmdValues = 1;
    }else{
      azDiffCmd = diff_command_external(&nDiffCmdValues, isGDiff);
    }
  }
  zBinGlob = diff_get_binary_glob();
  fIncludeBinary = diff_include_binary_files();
  determine_exec_relative_option(1);
  verify_all_options();
  if( g.argc>=3 ){
    int i;

    }
  }
  if( againstUndo ){
    if( db_lget_int("undo_available",0)==0 ){
      fossil_print("No undo or redo is available\n");
      return;
    }
    diff_against_undo(azDiffCmd, nDiffCmdValues, zBinGlob, fIncludeBinary,
                      diffFlags, pFileDir);
  }else if( zTo==0 ){
    diff_against_disk(zFrom, azDiffCmd, nDiffCmdValues, zBinGlob, fIncludeBinary,
                      diffFlags, pFileDir, 0);
  }else{
    diff_two_versions(zFrom, zTo, azDiffCmd, nDiffCmdValues, zBinGlob, fIncludeBinary,
                      diffFlags, pFileDir);
  }
  if( pFileDir ){
    int i;
    for(i=0; pFileDir[i].zName; i++){
      if( pFileDir[i].nUsed==0
       && strcmp(pFileDir[0].zName,".")!=0

  const char *zFrom = P("from");
  const char *zTo = P("to");
  login_check_credentials();
  if( !g.perm.Read ){ login_needed(g.anon.Read); return; }
  if( zFrom==0 || zTo==0 ) fossil_redirect_home();

  cgi_set_content_type("text/plain");
  diff_two_versions(zFrom, zTo, 0, 0, 0, 0, DIFF_VERBOSE, 0);
}

}

/*
** Show the diffs associate with a single stash.
*/
static void stash_diff(
  int stashid,             /* The stash entry to diff */
  const char *azDiffCmd[],  /* External diff cmd and optional args */
  size_t nDiffCmdValues,   /* Elements in azDiffCmd; 0 for internal */
  const char *zBinGlob,    /* GLOB pattern to determine binary files */
  int fBaseline,           /* Diff against original baseline check-in if true */
  int fIncludeBinary,      /* Do diffs against binary files */
  u64 diffFlags            /* Other diff flags */
){
  Stmt q;
  Blob empty;

    Blob a, b;
    if( rid==0 ){
      db_ephemeral_blob(&q, 6, &a);
      fossil_print("ADDED %s\n", zNew);
      diff_print_index(zNew, diffFlags, 0);
      isBin1 = 0;
      isBin2 = fIncludeBinary ? 0 : looks_like_binary(&a);
      diff_file_mem(&empty, &a, isBin1, isBin2, zNew, azDiffCmd, nDiffCmdValues,
                    zBinGlob, fIncludeBinary, diffFlags);
    }else if( isRemoved ){
      fossil_print("DELETE %s\n", zOrig);
      diff_print_index(zNew, diffFlags, 0);
      isBin2 = 0;
      if( fBaseline ){
        content_get(rid, &a);
        isBin1 = fIncludeBinary ? 0 : looks_like_binary(&a);
        diff_file_mem(&a, &empty, isBin1, isBin2, zOrig, azDiffCmd, nDiffCmdValues,
                      zBinGlob, fIncludeBinary, diffFlags);
      }else{
      }
    }else{
      Blob delta;
      int isOrigLink = file_islink(zOPath);
      db_ephemeral_blob(&q, 6, &delta);
      fossil_print("CHANGED %s\n", zNew);
      if( !isOrigLink != !isLink ){
        diff_print_index(zNew, diffFlags, 0);
        diff_print_filenames(zOrig, zNew, diffFlags, 0);
        printf(DIFF_CANNOT_COMPUTE_SYMLINK);
      }else{
        content_get(rid, &a);
        blob_delta_apply(&a, &delta, &b);
        isBin1 = fIncludeBinary ? 0 : looks_like_binary(&a);
        isBin2 = fIncludeBinary ? 0 : looks_like_binary(&b);
        if( fBaseline ){
          diff_file_mem(&a, &b, isBin1, isBin2, zNew,
                        azDiffCmd, nDiffCmdValues, zBinGlob, fIncludeBinary, diffFlags);
        }else{
          /*Diff with file on disk using fSwapDiff=1 to show the diff in the
            same direction as if fBaseline=1.*/
          diff_file(&b, isBin2, zOPath, zNew, azDiffCmd, nDiffCmdValues,
              zBinGlob, fIncludeBinary, diffFlags, 1, 0);
        }
        blob_reset(&a);
        blob_reset(&b);
      }
      blob_reset(&delta);
    }

  if( memcmp(zCmd, "diff", nCmd)==0
   || memcmp(zCmd, "gdiff", nCmd)==0
   || memcmp(zCmd, "show", nCmd)==0
   || memcmp(zCmd, "gshow", nCmd)==0
   || memcmp(zCmd, "cat", nCmd)==0
   || memcmp(zCmd, "gcat", nCmd)==0
  ){
    const char **azDiffCmd = 0;
    size_t nDiffCmdValues = 0;
    const char *zBinGlob = 0;
    int fIncludeBinary = 0;
    int fBaseline = 0;
    u64 diffFlags;

    if( strstr(zCmd,"show")!=0 || strstr(zCmd,"cat")!=0 ){
      fBaseline = 1;
    }
    if( find_option("tk",0,0)!=0 ){
      db_close(0);
      diff_tk(fBaseline ? "stash show" : "stash diff", 3);
      return;
    }
    if( find_option("internal","i",0)==0 ){
      azDiffCmd = diff_command_external(&nDiffCmdValues, zCmd[0]=='g');
    }
    diffFlags = diff_options();
    if( find_option("verbose","v",0)!=0 ) diffFlags |= DIFF_VERBOSE;
    if( g.argc>4 ) usage(mprintf("%s ?STASHID? ?DIFF-OPTIONS?", zCmd));
    if( nDiffCmdValues==0 ){
      zBinGlob = diff_get_binary_glob();
      fIncludeBinary = diff_include_binary_files();
    }
    stashid = stash_get_id(g.argc==4 ? g.argv[3] : 0);
    stash_diff(stashid, azDiffCmd, nDiffCmdValues, zBinGlob, fBaseline, fIncludeBinary,
               diffFlags);
  }else
  if( memcmp(zCmd, "help", nCmd)==0 ){
    g.argv[1] = "help";
    g.argv[2] = "stash";
    g.argc = 3;
    help_cmd();
  }else
  {
    usage("SUBCOMMAND ARGS...");
  }
  db_end_transaction(0);
}