hdiffpatch 1.0.0__cp39-cp39-win32.whl

hdiffpatch/_c_src/HDiffPatch/hdiffz.cpp

@@ -0,0 +1,2112 @@
+//hdiffz.cpp
+// diff tool
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2021 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "libHDiffPatch/HDiff/diff.h"
+#include "libHDiffPatch/HDiff/match_block.h"
+#include "libHDiffPatch/HPatch/patch.h"
+#include "_clock_for_demo.h"
+#include "_atosize.h"
+#include "file_for_patch.h"
+#include "libHDiffPatch/HDiff/private_diff/mem_buf.h"
+#include "hdiffz_import_patch.h"
+
+#include "_dir_ignore.h"
+#include "dirDiffPatch/dir_diff/dir_diff.h"
+
+#ifndef _IS_NEED_MAIN
+#   define  _IS_NEED_MAIN 1
+#endif
+#ifndef _IS_NEED_BSDIFF
+#   define _IS_NEED_BSDIFF 1
+#endif
+#ifndef _IS_NEED_VCDIFF
+#   define _IS_NEED_VCDIFF 1
+#endif
+
+#ifndef _IS_NEED_DEFAULT_CompressPlugin
+#   define _IS_NEED_DEFAULT_CompressPlugin 1
+#endif
+#if (_IS_NEED_ALL_CompressPlugin)
+#   undef  _IS_NEED_DEFAULT_CompressPlugin
+#   define _IS_NEED_DEFAULT_CompressPlugin 1
+#endif
+#if (_IS_NEED_DEFAULT_CompressPlugin)
+//===== select needs decompress plugins or change to your plugin=====
+#   define _CompressPlugin_zlib  // memory requires less
+#   define _CompressPlugin_ldef  // faster or better compress than zlib / (now used ldef+zlib decompressor)
+#   define _CompressPlugin_bz2
+#   define _CompressPlugin_lzma  // better compresser
+#   define _CompressPlugin_lzma2 // better compresser
+#   define _CompressPlugin_zstd  // better compresser / faster decompressor
+#if (_IS_NEED_VCDIFF)
+#   define _CompressPlugin_7zXZ  //only for VCDIFF, used lzma2
+#endif
+
+#endif
+#if (_IS_NEED_ALL_CompressPlugin)
+//===== select needs decompress plugins or change to your plugin=====
+#   define _CompressPlugin_lz4   // faster compresser / faster decompressor
+#   define _CompressPlugin_lz4hc // compress slower & better than lz4 / (used lz4 decompressor) 
+#   define _CompressPlugin_brotli// better compresser / faster decompressor
+#   define _CompressPlugin_lzham // better compresser / decompress faster than lzma2
+#   define _CompressPlugin_tuz   // slower compresser / decompress requires tiny code(.text) & ram
+#endif
+#ifdef _CompressPlugin_ldef
+#   ifndef _CompressPlugin_ldef_is_use_zlib
+#       define _CompressPlugin_ldef_is_use_zlib         1 //now ldef need zlib decompressor for any all of deflate code
+#   endif
+#   ifndef _IS_NEED_decompressor_ldef_replace_zlib
+#       define _IS_NEED_decompressor_ldef_replace_zlib  0 
+#   endif
+#endif
+
+#if (_IS_NEED_BSDIFF)
+#   include "bsdiff_wrapper/bsdiff_wrapper.h"
+#   include "bsdiff_wrapper/bspatch_wrapper.h"
+#   ifndef _CompressPlugin_bz2
+#       define _CompressPlugin_bz2  //bsdiff need bz2
+#   endif
+#endif
+#if (_IS_NEED_VCDIFF)
+#   include "vcdiff_wrapper/vcdiff_wrapper.h"
+#   include "vcdiff_wrapper/vcpatch_wrapper.h"
+#endif
+
+#include "compress_plugin_demo.h"
+#include "decompress_plugin_demo.h"
+
+
+#if (_IS_NEED_DIR_DIFF_PATCH)
+
+#ifndef _IS_NEED_DEFAULT_ChecksumPlugin
+#   define _IS_NEED_DEFAULT_ChecksumPlugin 1
+#endif
+#if (_IS_NEED_ALL_ChecksumPlugin)
+#   undef  _IS_NEED_DEFAULT_ChecksumPlugin
+#   define _IS_NEED_DEFAULT_ChecksumPlugin 1
+#endif
+#if (_IS_NEED_DEFAULT_ChecksumPlugin)
+//===== select needs checksum plugins or change to your plugin=====
+#   define _ChecksumPlugin_crc32    //    32 bit effective  //need zlib
+#   define _ChecksumPlugin_fadler64 // ?  63 bit effective
+#endif
+#if (_IS_NEED_ALL_ChecksumPlugin)
+//===== select needs checksum plugins or change to your plugin=====
+#   define _ChecksumPlugin_adler32  // ?  29 bit effective
+#   define _ChecksumPlugin_adler64  // ?  30 bit effective
+#   define _ChecksumPlugin_fadler32 // ~  32 bit effective
+#   define _ChecksumPlugin_fadler128// ?  81 bit effective
+#   define _ChecksumPlugin_md5      //   128 bit
+#   define _ChecksumPlugin_blake3   //   256 bit
+#   define _ChecksumPlugin_xxh3     //    64 bit fast
+#   define _ChecksumPlugin_xxh128   //   128 bit fast
+#endif
+
+#include "checksum_plugin_demo.h"
+#endif
+
+static void printVersion(){
+    printf("HDiffPatch::hdiffz v" HDIFFPATCH_VERSION_STRING "\n");
+}
+
+static void printHelpInfo(){
+    printf("  -h (or -?)\n"
+           "      print usage info.\n");
+}
+
+static void printUsage(){
+    printVersion();
+    printf("\n");
+    printf("diff    usage: hdiffz [options] oldPath newPath outDiffFile\n"
+           "test    usage: hdiffz    -t     oldPath newPath testDiffFile\n"
+           "resave  usage: hdiffz [-c-...]  diffFile outDiffFile\n"
+           "print    info: hdiffz -info diffFile\n"
+#if (_IS_NEED_DIR_DIFF_PATCH)
+           "get  manifest: hdiffz [-g#...] [-C-checksumType] inputPath -M#outManifestTxtFile\n"
+           "manifest diff: hdiffz [options] -M-old#oldManifestFile -M-new#newManifestFile\n"
+           "                      oldPath newPath outDiffFile\n"
+           "  oldPath newPath inputPath can be file or directory(folder),\n"
+#endif
+           "  oldPath can empty, and input parameter \"\"\n"
+           "options:\n"
+           "  -m[-matchScore]\n"
+           "      DEFAULT; all file load into Memory; best diffFileSize;\n"
+           "      requires (newFileSize+ oldFileSize*5(or *9 when oldFileSize>=2GB))+O(1)\n"
+           "        bytes of memory;\n"
+           "      matchScore>=0, DEFAULT -m-6, recommended bin: 0--4 text: 4--9 etc...\n"
+           "  -s[-matchBlockSize]\n"
+           "      all file load as Stream; fast;\n"
+           "      requires O(oldFileSize*16/matchBlockSize+matchBlockSize*5"
+#if (_IS_USED_MULTITHREAD)
+           "*parallelThreadNumber"
+#endif
+           ")bytes of memory;\n"
+           "      matchBlockSize>=4, DEFAULT -s-64, recommended 16,32,48,1k,64k,1m etc...\n"
+           "  -block-fastMatchBlockSize \n"
+           "      must run with -m;\n"
+           "      set block match befor slow byte-by-byte match, DEFAULT -block-4k;\n"
+           "      if set -block-0, means don't use block match;\n"
+           "      fastMatchBlockSize>=4, recommended 256,1k,64k,1m etc...\n"
+           "      if newData similar to oldData then diff speed++ & diff memory--,\n"
+           "      but small possibility outDiffFile's size+\n"
+           "  -cache \n"
+           "      must run with -m;\n"
+           "      set is use a big cache for slow match, DEFAULT false;\n"
+           "      if newData not similar to oldData then diff speed++,\n"
+           "      big cache max used O(oldFileSize) memory, and build slow(diff speed--)\n" 
+           "  -SD[-stepSize]\n"
+           "      create single compressed diffData, only need one decompress buffer\n"
+           "      when patch, and support step by step patching when step by step downloading!\n"
+           "      stepSize>=" _HDIFFPATCH_EXPAND_AND_QUOTE(hpatch_kStreamCacheSize) ", DEFAULT -SD-256k, recommended 64k,2m etc...\n"
+#if (_IS_NEED_BSDIFF)
+           "  -BSD\n"
+           "      create diffFile compatible with bsdiff4, unsupport input directory(folder).\n"
+           "      also support run with -SD (not used stepSize), then create single compressed\n"
+           "      diffFile compatible with endsley/bsdiff (https://github.com/mendsley/bsdiff).\n"
+#endif
+#if (_IS_NEED_VCDIFF)
+#   ifdef _CompressPlugin_7zXZ
+           "  -VCD[-compressLevel[-dictSize]]\n"
+           "      create diffFile compatible with VCDIFF, unsupport input directory(folder).\n"
+           "      DEFAULT no compress, out format same as $open-vcdiff ... or $xdelta3 -S -e -n ...\n"
+           "      if set compressLevel, out format same as $xdelta3 -S lzma -e -n ...\n"
+           "      compress by 7zXZ(xz), compressLevel in {0..9}, DEFAULT level 7;\n"
+           "      dictSize can like 4096 or 4k or 4m or 16m etc..., DEFAULT 8m\n"
+#       if (_IS_USED_MULTITHREAD)
+           "      support compress by multi-thread parallel.\n"
+#       endif
+#   else
+           "  -VCD\n"
+           "      create diffFile compatible with VCDIFF, unsupport input directory(folder).\n"
+           "      out format same as $open-vcdiff ... or $xdelta3 -S -e -n ...\n"
+#   endif
+           "      NOTE: out diffFile used large source window size!\n"
+#endif
+#if (_IS_USED_MULTITHREAD)
+           "  -p-parallelThreadNumber\n"
+           "      if parallelThreadNumber>1 then open multi-thread Parallel mode;\n"
+           "      DEFAULT -p-4; requires more memory!\n"
+           "  -p-search-searchThreadNumber\n"
+           "      must run with -s[-matchBlockSize];\n"
+           "      DEFAULT searchThreadNumber same as parallelThreadNumber;\n"
+           "      but multi-thread search need frequent random disk reads when matchBlockSize\n"
+           "      is small, so some times multi-thread maybe much slower than single-thread!\n"
+           "      if (searchThreadNumber<=1) then to close multi-thread search mode.\n"
+#endif
+           "  -c-compressType[-compressLevel]\n"
+           "      set outDiffFile Compress type, DEFAULT uncompress;\n"
+           "      for resave diffFile,recompress diffFile to outDiffFile by new set;\n"
+           "      support compress type & level & dict:\n"
+#ifdef _CompressPlugin_zlib
+           "        -c-zlib[-{1..9}[-dictBits]]     DEFAULT level 9\n"
+           "            dictBits can 9--15, DEFAULT 15.\n"
+#   if (_IS_USED_MULTITHREAD)
+           "            support run by multi-thread parallel, fast!\n"
+#   endif
+#endif
+#ifdef _CompressPlugin_ldef
+           "        -c-ldef[-{1..12}]               DEFAULT level 12\n"
+           "            compatible with -c-zlib, faster or better compress than zlib;\n"
+           "            used libdeflate compressor, & dictBits always 15.\n"
+#   if (_IS_USED_MULTITHREAD)
+           "            support run by multi-thread parallel, fast!\n"
+#   endif
+#endif
+#ifdef _CompressPlugin_bz2
+           "        -c-bzip2[-{1..9}]               (or -bz2) DEFAULT level 9\n"
+#   if (_IS_USED_MULTITHREAD)
+           "        -c-pbzip2[-{1..9}]              (or -pbz2) DEFAULT level 8\n"
+           "            support run by multi-thread parallel, fast!\n"
+           "            NOTE: code not compatible with it compressed by -c-bzip2!\n"
+#   endif
+#endif
+#ifdef _CompressPlugin_lzma
+           "        -c-lzma[-{0..9}[-dictSize]]     DEFAULT level 7\n"
+           "            dictSize can like 4096 or 4k or 4m or 128m etc..., DEFAULT 8m\n"
+#   if (_IS_USED_MULTITHREAD)
+           "            support run by 2-thread parallel.\n"
+#   endif
+#endif
+#ifdef _CompressPlugin_lzma2
+           "        -c-lzma2[-{0..9}[-dictSize]]    DEFAULT level 7\n"
+           "            dictSize can like 4096 or 4k or 4m or 128m etc..., DEFAULT 8m\n"
+#   if (_IS_USED_MULTITHREAD)
+           "            support run by multi-thread parallel, fast!\n"
+#   endif
+           "            NOTE: code not compatible with it compressed by -c-lzma!\n"
+#endif
+#ifdef _CompressPlugin_lz4
+           "        -c-lz4[-{1..50}]                DEFAULT level 50 (as lz4 acceleration 1)\n"
+#endif
+#ifdef _CompressPlugin_lz4hc
+           "        -c-lz4hc[-{3..12}]              DEFAULT level 11\n"
+#endif
+#ifdef _CompressPlugin_zstd
+           "        -c-zstd[-{0..22}[-dictBits]]    DEFAULT level 20\n"
+           "            dictBits can 10--30, DEFAULT 23.\n"
+#   if (_IS_USED_MULTITHREAD)
+           "            support run by multi-thread parallel, fast!\n"
+#   endif
+#endif
+#ifdef _CompressPlugin_brotli
+           "        -c-brotli[-{0..11}[-dictBits]]  DEFAULT level 9\n"
+           "            dictBits can 10--30, DEFAULT 23.\n"
+#endif
+#ifdef _CompressPlugin_lzham
+           "        -c-lzham[-{0..5}[-dictBits]]    DEFAULT level 4\n"
+           "            dictBits can 15--29, DEFAULT 23.\n"
+#   if (_IS_USED_MULTITHREAD)
+           "            support run by multi-thread parallel, fast!\n"
+#   endif
+#endif
+#ifdef _CompressPlugin_tuz
+           "        -c-tuz[-dictSize]               (or -tinyuz)\n"
+           "            1<=dictSize<=" _HDIFFPATCH_EXPAND_AND_QUOTE(tuz_kMaxOfDictSize) ", can like 510,1k,4k,64k,1m,16m ..., DEFAULT 8m\n"
+#endif
+#if (_IS_NEED_DIR_DIFF_PATCH)
+           "  -C-checksumType\n"
+           "      set outDiffFile Checksum type for directory diff, DEFAULT "
+#ifdef _ChecksumPlugin_fadler64
+           "-C-fadler64;\n"
+#else
+#   ifdef _ChecksumPlugin_crc32
+           "-C-crc32;\n"
+#   else
+           "no checksum;\n"
+#   endif
+           "      (if need checksum for diff between two files, add -D)\n"
+#endif
+           "      support checksum type:\n"
+           "        -C-no                   no checksum\n"
+#ifdef _ChecksumPlugin_crc32
+#   ifdef _ChecksumPlugin_fadler64
+           "        -C-crc32\n"
+#   else
+           "        -C-crc32                DEFAULT\n"
+#   endif
+#endif
+#ifdef _ChecksumPlugin_adler32
+           "        -C-adler32\n"
+#endif
+#ifdef _ChecksumPlugin_adler64
+           "        -C-adler64\n"
+#endif
+#ifdef _ChecksumPlugin_fadler32
+           "        -C-fadler32\n"
+#endif
+#ifdef _ChecksumPlugin_fadler64
+           "        -C-fadler64             DEFAULT\n"
+#endif
+#ifdef _ChecksumPlugin_fadler128
+           "        -C-fadler128\n"
+#endif
+#ifdef _ChecksumPlugin_md5
+           "        -C-md5\n"
+#endif
+#ifdef _ChecksumPlugin_blake3
+           "        -C-blake3\n"
+#endif
+#ifdef _ChecksumPlugin_xxh3
+           "        -C-xxh3\n"
+#endif
+#ifdef _ChecksumPlugin_xxh128
+           "        -C-xxh128\n"
+#endif
+           "  -n-maxOpenFileNumber\n"
+           "      limit Number of open files at same time when stream directory diff;\n"
+           "      maxOpenFileNumber>=8, DEFAULT -n-48, the best limit value by different\n"
+           "        operating system.\n"
+           "  -g#ignorePath[#ignorePath#...]\n"
+           "      set iGnore path list when Directory Diff; ignore path list such as:\n"
+           "        #.DS_Store#desktop.ini#*thumbs*.db#.git*#.svn/#cache_*/00*11/*.tmp\n"
+           "      # means separator between names; (if char # in name, need write #: )\n"
+           "      * means can match any chars in name; (if char * in name, need write *: );\n"
+           "      / at the end of name means must match directory;\n"
+           "  -g-old#ignorePath[#ignorePath#...]\n"
+           "      set iGnore path list in oldPath when Directory Diff;\n"
+           "      if oldFile can be changed, need add it in old ignore list;\n"
+           "  -g-new#ignorePath[#ignorePath#...]\n"
+           "      set iGnore path list in newPath when Directory Diff;\n"
+           "      in general, new ignore list should is empty;\n"
+           "  -M#outManifestTxtFile\n"
+           "      create a Manifest file for inputPath; it is a text file, saved infos of\n"
+           "      all files and directoriy list in inputPath; this file while be used in \n"
+           "      manifest diff, support re-checksum data by manifest diff;\n"
+           "      can be used to protect historical versions be modified!\n"
+           "  -M-old#oldManifestFile\n"
+           "      oldManifestFile is created from oldPath; if no oldPath not need -M-old;\n"
+           "  -M-new#newManifestFile\n"
+           "      newManifestFile is created from newPath;\n"
+           "  -D  force run Directory diff between two files; DEFAULT (no -D) run \n"
+           "      directory diff need oldPath or newPath is directory.\n"
+#endif //_IS_NEED_DIR_DIFF_PATCH
+           "  -neq\n"
+           "      open check: if newPath & oldPath's all datas are equal, then return error; \n"
+           "      DEFAULT not check equal.\n"
+           "  -d  Diff only, do't run patch check, DEFAULT run patch check.\n"
+           "  -t  Test only, run patch check, patch(oldPath,testDiffFile)==newPath ? \n"
+           "  -f  Force overwrite, ignore write path already exists;\n"
+           "      DEFAULT (no -f) not overwrite and then return error;\n"
+           "      if used -f and write path is exist directory, will always return error.\n"
+           "  --patch\n"
+           "      swap to hpatchz mode.\n"
+           "  -info\n"
+           "      print infos of diffFile.\n"
+           "  -v  print Version info.\n"
+           );
+    printHelpInfo();
+    printf("\n");
+}
+
+typedef enum THDiffResult {
+    HDIFF_SUCCESS=0,
+    HDIFF_OPTIONS_ERROR,
+    HDIFF_OPENREAD_ERROR,
+    HDIFF_OPENWRITE_ERROR,
+    HDIFF_FILECLOSE_ERROR,
+    HDIFF_MEM_ERROR, // 5
+    HDIFF_DIFF_ERROR,
+    HDIFF_PATCH_ERROR,
+    HDIFF_RESAVE_FILEREAD_ERROR,
+    //HDIFF_RESAVE_OPENWRITE_ERROR = HDIFF_OPENWRITE_ERROR
+    HDIFF_RESAVE_DIFFINFO_ERROR,
+    HDIFF_RESAVE_COMPRESSTYPE_ERROR, // 10
+    HDIFF_RESAVE_ERROR,
+    HDIFF_RESAVE_CHECKSUMTYPE_ERROR,
+    
+    HDIFF_PATHTYPE_ERROR, //adding begin v3.0
+    HDIFF_TEMPPATH_ERROR,
+    HDIFF_DELETEPATH_ERROR, // 15
+    HDIFF_RENAMEPATH_ERROR,
+    HDIFF_OLD_NEW_SAME_ERROR,//adding begin v4.7.0 ; note: now not included dir_diff(), dir_diff thow an error & return DIRDIFF_DIFF_ERROR
+    
+    DIRDIFF_DIFF_ERROR=101,
+    DIRDIFF_PATCH_ERROR,
+    MANIFEST_CREATE_ERROR,
+    MANIFEST_TEST_ERROR,
+} THDiffResult;
+#define HDIFF_RESAVE_OPENWRITE_ERROR HDIFF_OPENWRITE_ERROR
+
+int hdiff_cmd_line(int argc,const char * argv[]);
+
+struct TDiffSets:public THDiffSets{
+    hpatch_BOOL isDoDiff;
+    hpatch_BOOL isDoPatchCheck;
+#if (_IS_NEED_BSDIFF)
+    hpatch_BOOL isBsDiff;
+#endif
+#if (_IS_NEED_VCDIFF)
+    hpatch_BOOL isVcDiff;
+#endif
+};
+
+#if (_IS_NEED_DIR_DIFF_PATCH)
+int hdiff_dir(const char* oldPath,const char* newPath,const char* outDiffFileName,
+              const hdiff_TCompress* compressPlugin,hpatch_TChecksum* checksumPlugin,
+              hpatch_BOOL oldIsDir, hpatch_BOOL newIsDir,
+              const TDiffSets& diffSets,size_t kMaxOpenFileNumber,
+              const std::vector<std::string>& ignorePathListBase,const std::vector<std::string>& ignoreOldPathList,
+              const std::vector<std::string>& ignoreNewPathList,
+              const std::string& oldManifestFileName,const std::string& newManifestFileName);
+int create_manifest(const char* inputPath,const char* outManifestFileName,
+                    hpatch_TChecksum* checksumPlugin,const std::vector<std::string>& ignorePathList);
+#endif
+int hdiff(const char* oldFileName,const char* newFileName,const char* outDiffFileName,
+          const hdiff_TCompress* compressPlugin,const TDiffSets& diffSets);
+int hdiff_resave(const char* diffFileName,const char* outDiffFileName,
+                 const hdiff_TCompress* compressPlugin);
+
+#define _checkPatchMode(_argc,_argv)            \
+    if (isSwapToPatchMode(_argc,_argv)){        \
+        printf("hdiffz swap to hpatchz mode.\n\n"); \
+        return hpatch_cmd_line(_argc,_argv);    \
+    }
+
+#if (_IS_NEED_MAIN)
+#   if (_IS_USED_WIN32_UTF8_WAPI)
+int wmain(int argc,wchar_t* argv_w[]){
+    hdiff_private::TAutoMem  _mem(hpatch_kPathMaxSize*4);
+    char** argv_utf8=(char**)_mem.data();
+    if (!_wFileNames_to_utf8((const wchar_t**)argv_w,argc,argv_utf8,_mem.size()))
+        return HDIFF_OPTIONS_ERROR;
+    SetDefaultStringLocale();
+    _checkPatchMode(argc,(const char**)argv_utf8);
+    return hdiff_cmd_line(argc,(const char**)argv_utf8);
+}
+#   else
+int main(int argc,char* argv[]){
+    _checkPatchMode(argc,(const char**)argv);
+    return  hdiff_cmd_line(argc,(const char**)argv);
+}
+#   endif
+#endif
+
+
+static hpatch_BOOL _getIsCompressedDiffFile(const char* diffFileName){
+    hpatch_TFileStreamInput diffData;
+    hpatch_TFileStreamInput_init(&diffData);
+    if (!hpatch_TFileStreamInput_open(&diffData,diffFileName)) return hpatch_FALSE;
+    hpatch_compressedDiffInfo diffInfo;
+    hpatch_BOOL result=getCompressedDiffInfo(&diffInfo,&diffData.base);
+    if (!hpatch_TFileStreamInput_close(&diffData)) return hpatch_FALSE;
+    return result;
+}
+
+static hpatch_BOOL _getIsSingleStreamDiffFile(const char* diffFileName){
+    hpatch_TFileStreamInput diffData;
+    hpatch_TFileStreamInput_init(&diffData);
+    if (!hpatch_TFileStreamInput_open(&diffData,diffFileName)) return hpatch_FALSE;
+    hpatch_singleCompressedDiffInfo diffInfo;
+    hpatch_BOOL result=getSingleCompressedDiffInfo(&diffInfo,&diffData.base,0);
+    if (!hpatch_TFileStreamInput_close(&diffData)) return hpatch_FALSE;
+    return result;
+}
+
+#if (_IS_NEED_BSDIFF)
+static hpatch_BOOL _getIsBsDiffFile(const char* diffFileName) {
+    hpatch_TFileStreamInput diffData;
+    hpatch_TFileStreamInput_init(&diffData);
+    if (!hpatch_TFileStreamInput_open(&diffData, diffFileName)) return hpatch_FALSE;
+    hpatch_BOOL result=getIsBsDiff(&diffData.base,0);
+    if (!hpatch_TFileStreamInput_close(&diffData)) return hpatch_FALSE;
+    return result;
+}
+#endif
+#if (_IS_NEED_VCDIFF)
+static hpatch_BOOL _getIsVcDiffFile(const char* diffFileName) {
+    hpatch_TFileStreamInput diffData;
+    hpatch_TFileStreamInput_init(&diffData);
+    if (!hpatch_TFileStreamInput_open(&diffData, diffFileName)) return hpatch_FALSE;
+    hpatch_BOOL result=getIsVcDiff(&diffData.base);
+    if (!hpatch_TFileStreamInput_close(&diffData)) return hpatch_FALSE;
+    return result;
+}
+#endif
+
+
+#define _try_rt_dec(dec) { if (dec.is_can_open(compressType)) return &dec; }
+
+static hpatch_TDecompress* __find_decompressPlugin(const char* compressType){
+#if ((defined(_CompressPlugin_ldef))&&_IS_NEED_decompressor_ldef_replace_zlib)
+    _try_rt_dec(ldefDecompressPlugin);
+#else
+#  ifdef  _CompressPlugin_zlib
+    _try_rt_dec(zlibDecompressPlugin);
+#  endif
+#endif
+#ifdef  _CompressPlugin_bz2
+    _try_rt_dec(bz2DecompressPlugin);
+#endif
+#ifdef  _CompressPlugin_lzma
+    _try_rt_dec(lzmaDecompressPlugin);
+#endif
+#ifdef  _CompressPlugin_lzma2
+    _try_rt_dec(lzma2DecompressPlugin);
+#endif
+#if (defined(_CompressPlugin_lz4) || (defined(_CompressPlugin_lz4hc)))
+    _try_rt_dec(lz4DecompressPlugin);
+#endif
+#ifdef  _CompressPlugin_zstd
+    _try_rt_dec(zstdDecompressPlugin);
+#endif
+#ifdef  _CompressPlugin_brotli
+    _try_rt_dec(brotliDecompressPlugin);
+#endif
+#ifdef  _CompressPlugin_lzham
+    _try_rt_dec(lzhamDecompressPlugin);
+#endif
+#ifdef  _CompressPlugin_tuz
+    _try_rt_dec(tuzDecompressPlugin);
+#endif
+    return 0;
+}
+static hpatch_BOOL findDecompress(hpatch_TDecompress* out_decompressPlugin,const char* compressType){
+    memset(out_decompressPlugin,0,sizeof(hpatch_TDecompress));
+    if (strlen(compressType)==0) return hpatch_TRUE;
+    hpatch_TDecompress* decompressPlugin=__find_decompressPlugin(compressType);
+    if (decompressPlugin==0) return hpatch_FALSE;
+    *out_decompressPlugin=*decompressPlugin;
+    return hpatch_TRUE;
+}
+
+#if (_IS_NEED_DIR_DIFF_PATCH)
+static inline hpatch_BOOL _trySetChecksum(hpatch_TChecksum** out_checksumPlugin,const char* checksumType,
+                                          hpatch_TChecksum* testChecksumPlugin){
+    assert(0==*out_checksumPlugin);
+    if (0!=strcmp(checksumType,testChecksumPlugin->checksumType())) return hpatch_FALSE;
+    *out_checksumPlugin=testChecksumPlugin;
+    return hpatch_TRUE;
+}
+#define __setChecksum(_checksumPlugin) \
+    if (_trySetChecksum(out_checksumPlugin,checksumType,_checksumPlugin)) return hpatch_TRUE;
+
+static hpatch_BOOL findChecksum(hpatch_TChecksum** out_checksumPlugin,const char* checksumType){
+    *out_checksumPlugin=0;
+    if (strlen(checksumType)==0) return hpatch_TRUE;
+#ifdef _ChecksumPlugin_fadler64
+    __setChecksum(&fadler64ChecksumPlugin);
+#endif
+#ifdef _ChecksumPlugin_xxh128
+    __setChecksum(&xxh128ChecksumPlugin);
+#endif
+#ifdef _ChecksumPlugin_xxh3
+    __setChecksum(&xxh3ChecksumPlugin);
+#endif
+#ifdef _ChecksumPlugin_md5
+    __setChecksum(&md5ChecksumPlugin);
+#endif
+#ifdef _ChecksumPlugin_crc32
+    __setChecksum(&crc32ChecksumPlugin);
+#endif
+#ifdef _ChecksumPlugin_adler32
+    __setChecksum(&adler32ChecksumPlugin);
+#endif
+#ifdef _ChecksumPlugin_adler64
+    __setChecksum(&adler64ChecksumPlugin);
+#endif
+#ifdef _ChecksumPlugin_fadler32
+    __setChecksum(&fadler32ChecksumPlugin);
+#endif
+#ifdef _ChecksumPlugin_fadler128
+    __setChecksum(&fadler128ChecksumPlugin);
+#endif
+#ifdef _ChecksumPlugin_blake3
+    __setChecksum(&blake3ChecksumPlugin);
+#endif
+    return hpatch_FALSE;
+}
+
+static hpatch_BOOL _getOptChecksum(hpatch_TChecksum** out_checksumPlugin,
+                                   const char* checksumType,const char* kNoChecksum){
+    assert(0==*out_checksumPlugin);
+    if (0==strcmp(checksumType,kNoChecksum))
+        return hpatch_TRUE;
+    else
+        return findChecksum(out_checksumPlugin,checksumType);
+}
+
+#endif //_IS_NEED_DIR_DIFF_PATCH
+
+
+static bool _tryGetCompressSet(const char** isMatchedType,const char* ptype,const char* ptypeEnd,
+                               const char* cmpType,const char* cmpType2=0,
+                               size_t* compressLevel=0,size_t levelMin=0,size_t levelMax=0,size_t levelDefault=0,
+                               size_t* dictSize=0,size_t dictSizeMin=0,size_t dictSizeMax=0,size_t dictSizeDefault=0){
+    assert (0==(*isMatchedType));
+    const size_t ctypeLen=strlen(cmpType);
+    const size_t ctype2Len=(cmpType2!=0)?strlen(cmpType2):0;
+    if ( ((ctypeLen==(size_t)(ptypeEnd-ptype))&&(0==strncmp(ptype,cmpType,ctypeLen)))
+        || ((cmpType2!=0)&&(ctype2Len==(size_t)(ptypeEnd-ptype))&&(0==strncmp(ptype,cmpType2,ctype2Len))) )
+        *isMatchedType=cmpType; //ok
+    else
+        return true;//type mismatch
+    
+    if ((compressLevel)&&(ptypeEnd[0]=='-')){
+        const char* plevel=ptypeEnd+1;
+        const char* plevelEnd=findUntilEnd(plevel,'-');
+        if (!kmg_to_size(plevel,plevelEnd-plevel,compressLevel)) return false; //error
+        if (*compressLevel<levelMin) *compressLevel=levelMin;
+        else if (*compressLevel>levelMax) *compressLevel=levelMax;
+        if ((dictSize)&&(plevelEnd[0]=='-')){
+            const char* pdictSize=plevelEnd+1;
+            const char* pdictSizeEnd=findUntilEnd(pdictSize,'-');
+            if (!kmg_to_size(pdictSize,pdictSizeEnd-pdictSize,dictSize)) return false; //error
+            if (*dictSize<dictSizeMin) *dictSize=dictSizeMin;
+            else if (*dictSize>dictSizeMax) *dictSize=dictSizeMax;
+        }else{
+            if (plevelEnd[0]!='\0') return false; //error
+            if (dictSize) *dictSize=(dictSizeDefault<dictSizeMax)?dictSizeDefault:dictSizeMax;
+        }
+    }else{
+        if (ptypeEnd[0]!='\0') return false; //error
+        if (compressLevel) *compressLevel=levelDefault;
+        if (dictSize) *dictSize=dictSizeDefault;
+    }
+    return true;
+}
+
+#define _options_check(value,errorInfo){ \
+    if (!(value)) { LOG_ERR("options " errorInfo " ERROR!\n\n"); printHelpInfo(); return HDIFF_OPTIONS_ERROR; } }
+
+#define __getCompressSet(_tryGet_code,_errTag)  \
+    if (isMatchedType==0){                      \
+        _options_check(_tryGet_code,_errTag);   \
+        if (isMatchedType)
+
+static int _checkSetCompress(hdiff_TCompress** out_compressPlugin,
+                             const char* ptype,const char* ptypeEnd){
+    const char* isMatchedType=0;
+    size_t      compressLevel=0;
+#if (defined _CompressPlugin_lzma)||(defined _CompressPlugin_lzma2)||(defined _CompressPlugin_tuz)
+    size_t       dictSize=0;
+    const size_t defaultDictSize=(1<<20)*8; //8m
+#endif
+#if (defined _CompressPlugin_zlib)||(defined _CompressPlugin_ldef)||(defined _CompressPlugin_zstd) \
+        ||(defined _CompressPlugin_brotli)||(defined _CompressPlugin_lzham)
+    size_t       dictBits=0;
+    const size_t defaultDictBits=20+3; //8m
+    const size_t defaultDictBits_zlib=15; //32k
+#endif
+#ifdef _CompressPlugin_zlib
+    __getCompressSet(_tryGetCompressSet(&isMatchedType,ptype,ptypeEnd,"zlib","pzlib",
+                                        &compressLevel,1,9,9, &dictBits,9,15,defaultDictBits_zlib),"-c-zlib-?"){
+#   if (!_IS_USED_MULTITHREAD)
+        static TCompressPlugin_zlib _zlibCompressPlugin=zlibCompressPlugin;
+        _zlibCompressPlugin.compress_level=(int)compressLevel;
+        _zlibCompressPlugin.windowBits=(signed char)(-dictBits);
+        *out_compressPlugin=&_zlibCompressPlugin.base; }}
+#   else
+        static TCompressPlugin_pzlib _pzlibCompressPlugin=pzlibCompressPlugin;
+        _pzlibCompressPlugin.base.compress_level=(int)compressLevel;
+        _pzlibCompressPlugin.base.windowBits=(signed char)(-(int)dictBits);
+        *out_compressPlugin=&_pzlibCompressPlugin.base.base; }}
+#   endif // _IS_USED_MULTITHREAD
+#endif
+#ifdef _CompressPlugin_ldef
+    __getCompressSet(_tryGetCompressSet(&isMatchedType,ptype,ptypeEnd,"ldef","pldef",
+                                        &compressLevel,1,12,12, &dictBits,15,15,defaultDictBits_zlib),"-c-ldef-?"){
+#   if (!_IS_USED_MULTITHREAD)
+        static TCompressPlugin_ldef _ldefCompressPlugin=ldefCompressPlugin;
+        _ldefCompressPlugin.compress_level=(int)compressLevel;
+        *out_compressPlugin=&_ldefCompressPlugin.base; }}
+#   else
+        static TCompressPlugin_pldef _pldefCompressPlugin=pldefCompressPlugin;
+        _pldefCompressPlugin.base.compress_level=(int)compressLevel;
+        *out_compressPlugin=&_pldefCompressPlugin.base.base; }}
+#   endif // _IS_USED_MULTITHREAD
+#endif
+#ifdef _CompressPlugin_bz2
+    __getCompressSet(_tryGetCompressSet(&isMatchedType,ptype,ptypeEnd,"bzip2","bz2",
+                                        &compressLevel,1,9,9),"-c-bzip2-?"){
+        static TCompressPlugin_bz2 _bz2CompressPlugin=bz2CompressPlugin;
+        _bz2CompressPlugin.compress_level=(int)compressLevel;
+        *out_compressPlugin=&_bz2CompressPlugin.base; }}
+#   if (_IS_USED_MULTITHREAD)
+    //pbzip2
+    __getCompressSet(_tryGetCompressSet(&isMatchedType,ptype,ptypeEnd,"pbzip2","pbz2",
+                                        &compressLevel,1,9,8),"-c-pbzip2-?"){
+        static TCompressPlugin_pbz2 _pbz2CompressPlugin=pbz2CompressPlugin;
+        _pbz2CompressPlugin.base.compress_level=(int)compressLevel;
+        *out_compressPlugin=&_pbz2CompressPlugin.base.base; }}
+#   endif // _IS_USED_MULTITHREAD
+#endif
+#ifdef _CompressPlugin_lzma
+    __getCompressSet(_tryGetCompressSet(&isMatchedType,ptype,ptypeEnd,"lzma",0,
+                                        &compressLevel,0,9,7, &dictSize,1<<12,
+                                        (sizeof(size_t)<=4)?(1<<27):((size_t)3<<29),defaultDictSize),"-c-lzma-?"){
+        static TCompressPlugin_lzma _lzmaCompressPlugin=lzmaCompressPlugin;
+        _lzmaCompressPlugin.compress_level=(int)compressLevel;
+        _lzmaCompressPlugin.dict_size=(UInt32)dictSize;
+        *out_compressPlugin=&_lzmaCompressPlugin.base; }}
+#endif
+#ifdef _CompressPlugin_lzma2
+    __getCompressSet(_tryGetCompressSet(&isMatchedType,ptype,ptypeEnd,"lzma2",0,
+                                        &compressLevel,0,9,7, &dictSize,1<<12,
+                                        (sizeof(size_t)<=4)?(1<<27):((size_t)3<<29),defaultDictSize),"-c-lzma2-?"){
+        static TCompressPlugin_lzma2 _lzma2CompressPlugin=lzma2CompressPlugin;
+        _lzma2CompressPlugin.compress_level=(int)compressLevel;
+        _lzma2CompressPlugin.dict_size=(UInt32)dictSize;
+        *out_compressPlugin=&_lzma2CompressPlugin.base; }}
+#endif
+#ifdef _CompressPlugin_lz4
+    __getCompressSet(_tryGetCompressSet(&isMatchedType,ptype,ptypeEnd,"lz4",0,
+                                        &compressLevel,1,50,50),"-c-lz4-?"){
+        static TCompressPlugin_lz4 _lz4CompressPlugin=lz4CompressPlugin;
+        _lz4CompressPlugin.compress_level=(int)compressLevel;
+        *out_compressPlugin=&_lz4CompressPlugin.base; }}
+#endif
+#ifdef _CompressPlugin_lz4hc
+    __getCompressSet(_tryGetCompressSet(&isMatchedType,ptype,ptypeEnd,"lz4hc",0,
+                                        &compressLevel,3,12,11),"-c-lz4hc-?"){
+        static TCompressPlugin_lz4hc _lz4hcCompressPlugin=lz4hcCompressPlugin;
+        _lz4hcCompressPlugin.compress_level=(int)compressLevel;
+        *out_compressPlugin=&_lz4hcCompressPlugin.base; }}
+#endif
+#ifdef _CompressPlugin_zstd
+    __getCompressSet(_tryGetCompressSet(&isMatchedType,ptype,ptypeEnd,"zstd",0,
+                                        &compressLevel,0,22,20, &dictBits,10,
+                                        _ZSTD_WINDOWLOG_MAX,defaultDictBits),"-c-zstd-?"){
+        static TCompressPlugin_zstd _zstdCompressPlugin=zstdCompressPlugin;
+        _zstdCompressPlugin.compress_level=(int)compressLevel;
+        _zstdCompressPlugin.dict_bits = (int)dictBits;
+        *out_compressPlugin=&_zstdCompressPlugin.base; }}
+#endif
+#ifdef _CompressPlugin_brotli
+    __getCompressSet(_tryGetCompressSet(&isMatchedType,ptype,ptypeEnd,"brotli",0,
+                                        &compressLevel,0,11,9, &dictBits,10,
+                                        30,defaultDictBits),"-c-brotli-?"){
+        static TCompressPlugin_brotli _brotliCompressPlugin=brotliCompressPlugin;
+        _brotliCompressPlugin.compress_level=(int)compressLevel;
+        _brotliCompressPlugin.dict_bits = (int)dictBits;
+        *out_compressPlugin=&_brotliCompressPlugin.base; }}
+#endif
+#ifdef _CompressPlugin_lzham
+    __getCompressSet(_tryGetCompressSet(&isMatchedType,ptype,ptypeEnd,"lzham",0,
+                                        &compressLevel,0,5,4, &dictBits,15,
+                                        (sizeof(size_t)<=4)?26:29,defaultDictBits),"-c-lzham-?"){
+        static TCompressPlugin_lzham _lzhamCompressPlugin=lzhamCompressPlugin;
+        _lzhamCompressPlugin.compress_level=(int)compressLevel;
+        _lzhamCompressPlugin.dict_bits = (int)dictBits;
+        *out_compressPlugin=&_lzhamCompressPlugin.base; }}
+#endif
+#ifdef _CompressPlugin_tuz
+    __getCompressSet(_tryGetCompressSet(&isMatchedType,
+                                        ptype,ptypeEnd,"tuz","tinyuz",
+                                        &dictSize,1,tuz_kMaxOfDictSize,defaultDictSize),"-c-tuz-?"){
+        static TCompressPlugin_tuz _tuzCompressPlugin=tuzCompressPlugin;
+        _tuzCompressPlugin.props.dictSize=(tuz_size_t)dictSize;
+        *out_compressPlugin=&_tuzCompressPlugin.base; }}
+#endif
+
+    _options_check((*out_compressPlugin!=0),"-c-?");
+    return HDIFF_SUCCESS;
+}
+
+#define _return_check(value,exitCode,errorInfo){ \
+    if (!(value)) { LOG_ERR(errorInfo " ERROR!\n"); return exitCode; } }
+
+#define _kNULL_VALUE    ((hpatch_BOOL)(-1))
+#define _kNULL_SIZE     (~(size_t)0)
+
+#define _THREAD_NUMBER_NULL     _kNULL_SIZE
+#define _THREAD_NUMBER_DEFUALT  kDefaultCompressThreadNumber
+#define _THREAD_NUMBER_MAX      (1<<8)
+
+int hdiff_cmd_line(int argc, const char * argv[]){
+    TDiffSets diffSets; 
+    memset(&diffSets,0,sizeof(diffSets));
+#if (_IS_NEED_BSDIFF)
+    diffSets.isBsDiff = _kNULL_VALUE;
+#endif
+#if (_IS_NEED_VCDIFF)
+    diffSets.isVcDiff = _kNULL_VALUE;
+#endif
+    diffSets.isDoDiff =_kNULL_VALUE;
+    diffSets.isDoPatchCheck=_kNULL_VALUE;
+    diffSets.isDiffInMem   =_kNULL_VALUE;
+    diffSets.isSingleCompressedDiff =_kNULL_VALUE;
+    diffSets.isUseBigCacheMatch =_kNULL_VALUE;
+    diffSets.isCheckNotEqual =_kNULL_VALUE;
+    diffSets.matchBlockSize=_kNULL_SIZE;
+    diffSets.threadNum=_THREAD_NUMBER_NULL;
+    diffSets.threadNumSearch_s=_THREAD_NUMBER_NULL;
+    hpatch_BOOL isPrintFileInfo=_kNULL_VALUE;
+    hpatch_BOOL isForceOverwrite=_kNULL_VALUE;
+    hpatch_BOOL isOutputHelp=_kNULL_VALUE;
+    hpatch_BOOL isOutputVersion=_kNULL_VALUE;
+    hpatch_BOOL isOldPathInputEmpty=_kNULL_VALUE;
+    hdiff_TCompress*        compressPlugin=0;
+#if (_IS_NEED_DIR_DIFF_PATCH)
+    hpatch_BOOL             isForceRunDirDiff=_kNULL_VALUE;
+    size_t                  kMaxOpenFileNumber=_kNULL_SIZE; //only used in dir diff by stream
+    hpatch_BOOL             isSetChecksum=_kNULL_VALUE;
+    hpatch_TChecksum*       checksumPlugin=0;
+    std::string             manifestOut;
+    std::string             manifestOld;
+    std::string             manifestNew;
+    std::vector<std::string>    ignorePathList;
+    std::vector<std::string>    ignoreOldPathList;
+    std::vector<std::string>    ignoreNewPathList;
+#endif
+    std::vector<const char *> arg_values;
+    if (argc<=1){
+        printUsage();
+        return HDIFF_OPTIONS_ERROR;
+    }
+    for (int i=1; i<argc; ++i) {
+        const char* op=argv[i];
+        _options_check(op!=0,"?");
+        if (op[0]!='-'){
+            hpatch_BOOL isEmpty=(strlen(op)==0);
+            if (isEmpty){
+                if (isOldPathInputEmpty==_kNULL_VALUE)
+                    isOldPathInputEmpty=hpatch_TRUE;
+                else
+                    _options_check(!isEmpty,"?"); //error return
+            }else{
+                if (isOldPathInputEmpty==_kNULL_VALUE)
+                    isOldPathInputEmpty=hpatch_FALSE;
+            }
+            arg_values.push_back(op); //path:file or directory
+            continue;
+        }
+        switch (op[1]) {
+            case 'm':{ //diff in memory
+                _options_check((diffSets.isDiffInMem==_kNULL_VALUE)&&((op[2]=='\0')||(op[2]=='-')),"-m");
+                diffSets.isDiffInMem=hpatch_TRUE;
+                if (op[2]=='-'){
+                    const char* pnum=op+3;
+                    _options_check(kmg_to_size(pnum,strlen(pnum),&diffSets.matchScore),"-m-?");
+                    _options_check((0<=(int)diffSets.matchScore)&&(diffSets.matchScore==(size_t)(int)diffSets.matchScore),"-m-?");
+                }else{
+                    diffSets.matchScore=kMinSingleMatchScore_default;
+                }
+            } break;
+            case 's':{
+                _options_check((diffSets.isDiffInMem==_kNULL_VALUE)&&((op[2]=='\0')||(op[2]=='-')),"-s");
+                _options_check((diffSets.matchBlockSize==_kNULL_SIZE),"-block must run with -m");
+                diffSets.isDiffInMem=hpatch_FALSE; //diff by stream
+                if (op[2]=='-'){
+                    const char* pnum=op+3;
+                    _options_check(kmg_to_size(pnum,strlen(pnum),&diffSets.matchBlockSize),"-s-?");
+                    _options_check((kMatchBlockSize_min<=diffSets.matchBlockSize)
+                                 &&(diffSets.matchBlockSize!=_kNULL_SIZE),"-s-?");
+                }else{
+                    diffSets.matchBlockSize=kMatchBlockSize_default;
+                }
+            } break;
+            case 'S':{
+                _options_check((diffSets.isSingleCompressedDiff==_kNULL_VALUE)
+                               &&(op[2]=='D')&&((op[3]=='\0')||(op[3]=='-')),"-SD");
+                diffSets.isSingleCompressedDiff=hpatch_TRUE;
+                if (op[3]=='-'){
+                    const char* pnum=op+4;
+                    _options_check(kmg_to_size(pnum,strlen(pnum),&diffSets.patchStepMemSize),"-SD-?");
+                    _options_check((diffSets.patchStepMemSize>=hpatch_kStreamCacheSize),"-SD-?");
+                }else{
+                    diffSets.patchStepMemSize=kDefaultPatchStepMemSize;
+                }
+            } break;
+#if (_IS_NEED_BSDIFF)
+            case 'B':{
+                _options_check((diffSets.isBsDiff==_kNULL_VALUE)
+                               &&(op[2]=='S')&&(op[3]=='D')&&(op[4]=='\0'),"-BSD");
+                diffSets.isBsDiff=hpatch_TRUE;
+            } break;
+#endif
+#if (_IS_NEED_VCDIFF)
+#   ifdef _CompressPlugin_7zXZ
+            case 'V':{
+                _options_check((diffSets.isVcDiff==_kNULL_VALUE)&&(op[2]=='C')&&(op[3]=='D')
+                               &&((op[4]=='\0')||(op[4]=='-')),"-VCD");
+                _options_check((compressPlugin==0),"-VCD compress support 7zXZ, unsupport -c-*");
+                if (op[4]=='-'){
+                    size_t compressLevel;
+                    size_t dictSize;
+                    const char* isMatchedType=0;
+                    _options_check(_tryGetCompressSet(&isMatchedType,op+1,op+4,"VCD",0,
+                                    &compressLevel,0,9,7, &dictSize,1<<12,
+                                    vcdiff_kMaxTargetWindowsSize,(1<<20)*8),"-VCD-?");
+
+                    _init_CompressPlugin_7zXZ();
+                    static TCompressPlugin_7zXZ xzCompressPlugin=_7zXZCompressPlugin;
+                    xzCompressPlugin.compress_level=(int)compressLevel;
+                    xzCompressPlugin.dict_size=(UInt32)dictSize;
+                    compressPlugin=&xzCompressPlugin.base;
+                }
+                diffSets.isVcDiff=hpatch_TRUE;
+            } break;
+#   else
+            case 'V':{
+                _options_check((diffSets.isVcDiff==_kNULL_VALUE)&&(op[2]=='C')&&(op[3]=='D')
+                               &&(op[4]=='\0'),"-VCD");
+                _options_check((compressPlugin==0),"-VCD unsupport -c-*");
+                diffSets.isVcDiff=hpatch_TRUE;
+            } break;
+#   endif
+#endif
+            case 'i':{
+                _options_check((isPrintFileInfo==_kNULL_VALUE)&&(op[2]=='n')&&(op[3]=='f')
+                               &&(op[4]=='o')&&(op[5]=='\0'),"-info");
+                isPrintFileInfo=hpatch_TRUE;
+            } break;
+            case '?':
+            case 'h':{
+                _options_check((isOutputHelp==_kNULL_VALUE)&&(op[2]=='\0'),"-h");
+                isOutputHelp=hpatch_TRUE;
+            } break;
+            case 'v':{
+                _options_check((isOutputVersion==_kNULL_VALUE)&&(op[2]=='\0'),"-v");
+                isOutputVersion=hpatch_TRUE;
+            } break;
+            case 't':{
+                _options_check((diffSets.isDoDiff==_kNULL_VALUE)&&(diffSets.isDoPatchCheck==_kNULL_VALUE)&&(op[2]=='\0'),"-t -d?");
+                diffSets.isDoDiff=hpatch_FALSE;
+                diffSets.isDoPatchCheck=hpatch_TRUE; //only test diffFile
+            } break;
+            case 'd':{
+                _options_check((diffSets.isDoDiff==_kNULL_VALUE)&&(diffSets.isDoPatchCheck==_kNULL_VALUE)&&(op[2]=='\0'),"-t -d?");
+                diffSets.isDoDiff=hpatch_TRUE; //only diff
+                diffSets.isDoPatchCheck=hpatch_FALSE;
+            } break;
+            case 'f':{
+                _options_check((isForceOverwrite==_kNULL_VALUE)&&(op[2]=='\0'),"-f");
+                isForceOverwrite=hpatch_TRUE;
+            } break;
+#if (_IS_USED_MULTITHREAD)
+            case 'p':{
+                _options_check((op[2]=='-'),"-p?");
+                if ((op[3]=='s')){
+                    _options_check((diffSets.threadNumSearch_s==_THREAD_NUMBER_NULL)&&
+                        (op[4]=='e')&&(op[5]=='a')&&(op[6]=='r')&&(op[7]=='c')&&(op[8]=='h')&&(op[9]=='-'),"-p-search?");
+                    const char* pnum=op+10;
+                    _options_check(a_to_size(pnum,strlen(pnum),&diffSets.threadNumSearch_s),"-p-search-?");
+                }else{
+                    _options_check(diffSets.threadNum==_THREAD_NUMBER_NULL,"-p-?");
+                    const char* pnum=op+3;
+                    _options_check(a_to_size(pnum,strlen(pnum),&diffSets.threadNum),"-p-?");
+                }
+            } break;
+#endif
+            case 'b':{
+                _options_check((diffSets.matchBlockSize==_kNULL_SIZE)&&
+                    (op[2]=='l')&&(op[3]=='o')&&(op[4]=='c')&&(op[5]=='k')&&
+                    ((op[6]=='\0')||(op[6]=='-')),"-block?");
+                if (op[6]=='-'){
+                    const char* pnum=op+7;
+                    _options_check(kmg_to_size(pnum,strlen(pnum),&diffSets.matchBlockSize),"-block-?");
+                    if (diffSets.matchBlockSize!=0)
+                        _options_check((kMatchBlockSize_min<=diffSets.matchBlockSize)
+                                     &&(diffSets.matchBlockSize!=_kNULL_SIZE),"-block-?");
+                }else{
+                    diffSets.matchBlockSize=kDefaultFastMatchBlockSize;
+                }
+            } break;
+            case 'c':{
+                if (op[2]=='-'){
+                    _options_check((compressPlugin==0),"-c-");
+                    const char* ptype=op+3;
+                    const char* ptypeEnd=findUntilEnd(ptype,'-');
+                    int result=_checkSetCompress(&compressPlugin,ptype,ptypeEnd);
+                    if (HDIFF_SUCCESS!=result)
+                        return result;
+                }else if (op[2]=='a'){
+                    _options_check((diffSets.isUseBigCacheMatch==_kNULL_VALUE)&&
+                        (op[3]=='c')&&(op[4]=='h')&&(op[5]=='e')&&(op[6]=='\0'),"-cache?");
+                    diffSets.isUseBigCacheMatch=hpatch_TRUE; //use big cache for match 
+                }else{
+                    _options_check(false,"-c?");
+                }
+            } break;
+#if (_IS_NEED_DIR_DIFF_PATCH)
+            case 'C':{
+                _options_check((isSetChecksum==_kNULL_VALUE)&&(checksumPlugin==0)&&(op[2]=='-'),"-C");
+                const char* ptype=op+3;
+                isSetChecksum=hpatch_TRUE;
+                _options_check(_getOptChecksum(&checksumPlugin,ptype,"no"),"-C-?");
+            } break;
+            case 'g':{
+                if (op[2]=='#'){ //-g#
+                    const char* plist=op+3;
+                    _options_check(_getIgnorePathSetList(ignorePathList,plist),"-g#?");
+                }else if (op[2]=='-'){
+                    const char* plist=op+7;
+                    if ((op[3]=='o')&&(op[4]=='l')&&(op[5]=='d')&&(op[6]=='#')){
+                        _options_check(_getIgnorePathSetList(ignoreOldPathList,plist),"-g-old#?");
+                    }else if ((op[3]=='n')&&(op[4]=='e')&&(op[5]=='w')&&(op[6]=='#')){
+                        _options_check(_getIgnorePathSetList(ignoreNewPathList,plist),"-g-new#?");
+                    }else{
+                        _options_check(hpatch_FALSE,"-g-?");
+                    }
+                }else{
+                    _options_check(hpatch_FALSE,"-g?");
+                }
+            } break;
+            case 'M':{
+                if (op[2]=='#'){ //-M#
+                    const char* plist=op+3;
+                    _options_check(manifestOut.empty()&&manifestOld.empty()&&manifestNew.empty(),"-M#");
+                    manifestOut=plist;
+                }else if (op[2]=='-'){
+                    const char* plist=op+7;
+                    if ((op[3]=='o')&&(op[4]=='l')&&(op[5]=='d')&&(op[6]=='#')){
+                        _options_check(manifestOut.empty()&&manifestOld.empty(),"-M-old#");
+                        manifestOld=plist;
+                    }else if ((op[3]=='n')&&(op[4]=='e')&&(op[5]=='w')&&(op[6]=='#')){
+                        _options_check(manifestOut.empty()&&manifestNew.empty(),"-M-new#");
+                        manifestNew=plist;
+                    }else{
+                        _options_check(hpatch_FALSE,"-M-?");
+                    }
+                }else{
+                    _options_check(hpatch_FALSE,"-M?");
+                }
+            } break;
+            case 'D':{
+                _options_check((isForceRunDirDiff==_kNULL_VALUE)&&(op[2]=='\0'),"-D");
+                isForceRunDirDiff=hpatch_TRUE; //force run DirDiff
+            } break;
+#endif
+            case 'n':{
+                _options_check((op[2]!='\0'), "-n?");
+#if (_IS_NEED_DIR_DIFF_PATCH)
+                if (op[2]=='-'){
+                    _options_check((kMaxOpenFileNumber == _kNULL_SIZE), "-n-")
+                        const char* pnum = op + 3;
+                    _options_check(kmg_to_size(pnum, strlen(pnum), &kMaxOpenFileNumber), "-n-?");
+                    _options_check((kMaxOpenFileNumber != _kNULL_SIZE), "-n-?");
+                }else
+#endif
+                {
+                    _options_check((diffSets.isCheckNotEqual==_kNULL_VALUE)&&(op[2]=='e')&&(op[3]=='q')&&(op[4]=='\0'),"-neq");
+                    diffSets.isCheckNotEqual=hpatch_TRUE;
+                }
+            } break;
+            default: {
+                _options_check(hpatch_FALSE,"-?");
+            } break;
+        }//switch
+    }
+
+    if (isOutputHelp==_kNULL_VALUE)
+        isOutputHelp=hpatch_FALSE;
+    if (isOutputVersion==_kNULL_VALUE)
+        isOutputVersion=hpatch_FALSE;
+    if (isForceOverwrite==_kNULL_VALUE)
+        isForceOverwrite=hpatch_FALSE;
+    if (isPrintFileInfo==_kNULL_VALUE)
+        isPrintFileInfo=hpatch_FALSE;
+    if (isOutputHelp||isOutputVersion){
+        if (isOutputHelp)
+            printUsage();//with version
+        else
+            printVersion();
+        if (arg_values.empty())
+            return 0; //ok
+    }
+    if (isPrintFileInfo){
+        return hpatch_printFilesInfos((int)arg_values.size(),arg_values.data());
+    }
+    if (diffSets.isCheckNotEqual==_kNULL_VALUE)
+        diffSets.isCheckNotEqual=hpatch_FALSE;
+    if (diffSets.isSingleCompressedDiff==_kNULL_VALUE)
+        diffSets.isSingleCompressedDiff=hpatch_FALSE;
+#if (_IS_NEED_BSDIFF)
+    if (diffSets.isBsDiff==_kNULL_VALUE)
+        diffSets.isBsDiff=hpatch_FALSE;
+    if (diffSets.isBsDiff){
+        if (compressPlugin!=0){
+            _options_check(0==strcmp(compressPlugin->compressType(),"bz2"),"bsdiff must run with -c-bz2");
+        }else{
+            static TCompressPlugin_bz2 _bz2CompressPlugin=bz2CompressPlugin;
+            compressPlugin=&_bz2CompressPlugin.base;
+        }
+    }
+#endif
+#if (_IS_NEED_VCDIFF)
+    if (diffSets.isVcDiff==_kNULL_VALUE)
+        diffSets.isVcDiff=hpatch_FALSE;
+    if (diffSets.isVcDiff){
+        _options_check(!diffSets.isSingleCompressedDiff,"-SD -VCD can only set one");
+#if (_IS_NEED_BSDIFF)
+        _options_check(!diffSets.isBsDiff,"-BSD -VCD can only set one");
+#endif
+    }
+#endif
+#if (_IS_NEED_DIR_DIFF_PATCH)
+    if (isSetChecksum==_kNULL_VALUE)
+        isSetChecksum=hpatch_FALSE;
+    if (kMaxOpenFileNumber==_kNULL_SIZE)
+        kMaxOpenFileNumber=kMaxOpenFileNumber_default_diff;
+    if (kMaxOpenFileNumber<kMaxOpenFileNumber_default_min)
+        kMaxOpenFileNumber=kMaxOpenFileNumber_default_min;
+#endif
+    if (diffSets.isDiffInMem&&(diffSets.matchBlockSize==_kNULL_SIZE))
+        diffSets.matchBlockSize=kDefaultFastMatchBlockSize;
+    if (diffSets.threadNum==_THREAD_NUMBER_NULL)
+        diffSets.threadNum=_THREAD_NUMBER_DEFUALT;
+    else if (diffSets.threadNum>_THREAD_NUMBER_MAX)
+        diffSets.threadNum=_THREAD_NUMBER_MAX;
+    else if (diffSets.threadNum<1)
+        diffSets.threadNum=1;
+    if (diffSets.threadNumSearch_s==_THREAD_NUMBER_NULL)
+        diffSets.threadNumSearch_s=diffSets.threadNum;
+    else if (diffSets.threadNumSearch_s>_THREAD_NUMBER_MAX)
+        diffSets.threadNumSearch_s=_THREAD_NUMBER_MAX;
+    else if (diffSets.threadNumSearch_s<1)
+        diffSets.threadNumSearch_s=1;
+    if (compressPlugin!=0){
+        compressPlugin->setParallelThreadNumber(compressPlugin,(int)diffSets.threadNum);
+    }
+    
+    if (isOldPathInputEmpty==_kNULL_VALUE)
+        isOldPathInputEmpty=hpatch_FALSE;
+    _options_check((arg_values.size()==1)||(arg_values.size()==2)||(arg_values.size()==3),"input count");
+    if (arg_values.size()==3){ //diff
+        if (diffSets.isDiffInMem==_kNULL_VALUE){
+            diffSets.isDiffInMem=hpatch_TRUE;
+            diffSets.matchScore=kMinSingleMatchScore_default;
+        }
+        if (diffSets.isDoDiff==_kNULL_VALUE)
+            diffSets.isDoDiff=hpatch_TRUE;
+        if (diffSets.isDoPatchCheck==_kNULL_VALUE)
+            diffSets.isDoPatchCheck=hpatch_TRUE;
+        assert(diffSets.isDoDiff||diffSets.isDoPatchCheck);
+        if (diffSets.isUseBigCacheMatch==_kNULL_VALUE)
+            diffSets.isUseBigCacheMatch=hpatch_FALSE;
+        if (diffSets.isDoDiff&&(!diffSets.isDiffInMem)){
+            _options_check(!diffSets.isUseBigCacheMatch, "-cache must run with -m");
+        }
+        
+#if (_IS_NEED_DIR_DIFF_PATCH)
+        if (isForceRunDirDiff==_kNULL_VALUE)
+            isForceRunDirDiff=hpatch_FALSE;
+        if ((!manifestOld.empty())||(!manifestNew.empty())){
+            isForceRunDirDiff=hpatch_TRUE;
+            _options_check(manifestOut.empty()&&(!manifestNew.empty()),"-M?");
+            if (isOldPathInputEmpty){
+                _options_check(manifestOld.empty(),"-M?");
+            }else{
+                _options_check(!manifestOld.empty(),"-M?");
+            }
+            _options_check(ignorePathList.empty()&&ignoreOldPathList.empty()
+                           &&ignoreNewPathList.empty(),"-M can't run with -g");
+        }
+#endif
+
+        const char* oldPath        =arg_values[0];
+        const char* newPath        =arg_values[1];
+        const char* outDiffFileName=arg_values[2];
+        
+        _return_check(!hpatch_getIsSamePath(oldPath,outDiffFileName),
+                      HDIFF_PATHTYPE_ERROR,"oldPath outDiffFile same path");
+        _return_check(!hpatch_getIsSamePath(newPath,outDiffFileName),
+                      HDIFF_PATHTYPE_ERROR,"newPath outDiffFile same path");
+        if (!isForceOverwrite){
+            hpatch_TPathType   outDiffFileType;
+            _return_check(hpatch_getPathStat(outDiffFileName,&outDiffFileType,0),
+                          HDIFF_PATHTYPE_ERROR,"get outDiffFile type");
+            _return_check((outDiffFileType==kPathType_notExist)||(!diffSets.isDoDiff),
+                          HDIFF_PATHTYPE_ERROR,"diff outDiffFile already exists, overwrite");
+        }
+        hpatch_TPathType oldType;
+        hpatch_TPathType newType;
+        if (isOldPathInputEmpty){
+            oldType=kPathType_file;     //as empty file
+            diffSets.isDiffInMem=hpatch_FALSE;     //not need -m, set as -s
+            diffSets.matchBlockSize=kDefaultFastMatchBlockSize; //not used
+            diffSets.isUseBigCacheMatch=hpatch_FALSE;
+        }else{
+            _return_check(hpatch_getPathStat(oldPath,&oldType,0),HDIFF_PATHTYPE_ERROR,"get oldPath type");
+            _return_check((oldType!=kPathType_notExist),HDIFF_PATHTYPE_ERROR,"oldPath not exist");
+        }
+        _return_check(hpatch_getPathStat(newPath,&newType,0),HDIFF_PATHTYPE_ERROR,"get newPath type");
+        _return_check((newType!=kPathType_notExist),HDIFF_PATHTYPE_ERROR,"newPath not exist");
+#if (_IS_NEED_DIR_DIFF_PATCH)
+        hpatch_BOOL isUseDirDiff=isForceRunDirDiff||(kPathType_dir==oldType)||(kPathType_dir==newType);
+        if (isUseDirDiff){
+#ifdef _ChecksumPlugin_fadler64
+            if (isSetChecksum==hpatch_FALSE)
+                checksumPlugin=&fadler64ChecksumPlugin; //DEFAULT
+#else
+#   ifdef _ChecksumPlugin_crc32
+            if (isSetChecksum==hpatch_FALSE)
+                checksumPlugin=&crc32ChecksumPlugin; //DEFAULT
+#   endif
+#endif
+        }else
+        {
+            _options_check(checksumPlugin==0,"-C now only support dir diff, unsupport diff");
+        }
+#endif //_IS_NEED_DIR_DIFF_PATCH
+
+#if (_IS_NEED_DIR_DIFF_PATCH)
+        if (isUseDirDiff){
+#if (_IS_NEED_BSDIFF)
+            _options_check(!diffSets.isBsDiff,"bsdiff unsupport dir diff");
+#endif
+#if (_IS_NEED_VCDIFF)
+            _options_check(!diffSets.isVcDiff,"VCDIFF unsupport dir diff");
+#endif
+            return hdiff_dir(oldPath,newPath,outDiffFileName,compressPlugin,
+                             checksumPlugin,(kPathType_dir==oldType),(kPathType_dir==newType), 
+                             diffSets,kMaxOpenFileNumber,
+                             ignorePathList,ignoreOldPathList,ignoreNewPathList,
+                             manifestOld,manifestNew);
+        }else
+#endif
+        {
+            return hdiff(oldPath,newPath,outDiffFileName,
+                         compressPlugin,diffSets);
+        }
+#if (_IS_NEED_DIR_DIFF_PATCH)
+    }else if (!manifestOut.empty()){ //() //create manifest
+        _options_check(arg_values.size()==1,"create manifest file used one inputPath");
+        _options_check(ignoreOldPathList.empty(),"-g-old unsupport run with create manifest file mode");
+        _options_check(ignoreNewPathList.empty(),"-g-new unsupport run with create manifest file mode");
+
+#ifdef _ChecksumPlugin_fadler64
+        if (isSetChecksum==hpatch_FALSE)
+            checksumPlugin=&fadler64ChecksumPlugin; //DEFAULT
+#else
+#   ifdef _ChecksumPlugin_crc32
+        if (isSetChecksum==hpatch_FALSE)
+            checksumPlugin=&crc32ChecksumPlugin; //DEFAULT
+#   endif
+#endif
+
+        if (checksumPlugin==0) { printf("WARNING: create manifest file not set chercksum!\n\n"); }
+        const char* inputPath =arg_values[0];
+        if (!isForceOverwrite){
+            hpatch_TPathType   outFileType;
+            _return_check(hpatch_getPathStat(manifestOut.c_str(),&outFileType,0),
+                          HDIFF_PATHTYPE_ERROR,"get outManifestFile type");
+            _return_check(outFileType==kPathType_notExist,
+                          HDIFF_PATHTYPE_ERROR,"create outManifestFile already exists, overwrite");
+        }
+        return create_manifest(inputPath,manifestOut.c_str(),checksumPlugin,ignorePathList);
+#endif
+    }else{// (arg_values.size()==2)  //resave
+        _options_check(!isOldPathInputEmpty,"can't resave, must input a diffFile");
+        _options_check((diffSets.isDoDiff==_kNULL_VALUE),"-d unsupport run with resave mode");
+        _options_check((diffSets.isDoPatchCheck==_kNULL_VALUE),"-t unsupport run with resave mode");
+#if (_IS_NEED_BSDIFF)
+        _options_check((diffSets.isBsDiff==hpatch_FALSE),"-BSD unsupport run with resave mode");
+#endif
+#if (_IS_NEED_VCDIFF)
+        _options_check((diffSets.isVcDiff==hpatch_FALSE),"-VCD unsupport run with resave mode");
+#endif
+
+#if (_IS_NEED_DIR_DIFF_PATCH)
+        _options_check((isForceRunDirDiff==_kNULL_VALUE),"-D unsupport run with resave mode");
+        _options_check((checksumPlugin==0),"-C unsupport run with resave mode");
+#endif
+        const char* diffFileName   =arg_values[0];
+        const char* outDiffFileName=arg_values[1];
+        hpatch_BOOL isDiffFile=_getIsCompressedDiffFile(diffFileName);
+        isDiffFile=isDiffFile || _getIsSingleStreamDiffFile(diffFileName);
+#if (_IS_NEED_DIR_DIFF_PATCH)
+        isDiffFile=isDiffFile || getIsDirDiffFile(diffFileName);
+#endif
+#if (_IS_NEED_BSDIFF)
+        isDiffFile=isDiffFile || _getIsBsDiffFile(diffFileName);
+#endif
+#if (_IS_NEED_VCDIFF)
+        isDiffFile=isDiffFile || _getIsVcDiffFile(diffFileName);
+#endif
+        _return_check(isDiffFile,HDIFF_RESAVE_DIFFINFO_ERROR,"can't resave, input file is not diffFile");
+        if (!isForceOverwrite){
+            hpatch_TPathType   outDiffFileType;
+            _return_check(hpatch_getPathStat(outDiffFileName,&outDiffFileType,0),
+                          HDIFF_PATHTYPE_ERROR,"get outDiffFile type");
+            _return_check(outDiffFileType==kPathType_notExist,
+                          HDIFF_PATHTYPE_ERROR,"resave outDiffFile already exists, overwrite");
+        }
+        hpatch_BOOL isSamePath=hpatch_getIsSamePath(diffFileName,outDiffFileName);
+        if (isSamePath)
+            _return_check(isForceOverwrite,HDIFF_PATHTYPE_ERROR,"diffFile outDiffFile same name");
+        
+        if (!isSamePath){
+            return hdiff_resave(diffFileName,outDiffFileName,compressPlugin);
+        }else{
+            // 1. resave to newDiffTempName
+            // 2. if resave ok    then  { delelte oldDiffFile; rename newDiffTempName to oldDiffName; }
+            //    if resave error then  { delelte newDiffTempName; }
+            char newDiffTempName[hpatch_kPathMaxSize];
+            _return_check(hpatch_getTempPathName(outDiffFileName,newDiffTempName,newDiffTempName+hpatch_kPathMaxSize),
+                          HDIFF_TEMPPATH_ERROR,"getTempPathName(diffFile)");
+            printf("NOTE: out_diff temp file will be rename to in_diff name after resave!\n");
+            int result=hdiff_resave(diffFileName,newDiffTempName,compressPlugin);
+            if (result==0){//resave ok
+                _return_check(hpatch_removeFile(diffFileName),
+                              HDIFF_DELETEPATH_ERROR,"removeFile(diffFile)");
+                _return_check(hpatch_renamePath(newDiffTempName,diffFileName),
+                              HDIFF_RENAMEPATH_ERROR,"renamePath(temp,diffFile)");
+                printf("out_diff temp file renamed to in_diff name!\n");
+            }else{//resave error
+                if (!hpatch_removeFile(newDiffTempName)){
+                    printf("WARNING: can't remove temp file \"");
+                    hpatch_printPath_utf8(newDiffTempName); printf("\"\n");
+                }
+            }
+            return result;
+        }
+    }
+}
+
+#define _checkf(value,errorInfo) { if (!(value)) { \
+    LOG_ERR(errorInfo " ERROR!\n"); result=hpatch_FALSE; if (!_isInClear){ goto clear; } } }
+static hpatch_BOOL readFileAll(hdiff_private::TAutoMem& out_mem,const char* fileName){
+    hpatch_BOOL         result=hpatch_TRUE;
+    int                 _isInClear=hpatch_FALSE;
+    size_t              dataSize;
+    hpatch_TFileStreamInput    file;
+    hpatch_TFileStreamInput_init(&file);
+
+    _checkf(hpatch_TFileStreamInput_open(&file,fileName),"readFileAll() file open");
+    dataSize=(size_t)file.base.streamSize;
+    _checkf(dataSize==file.base.streamSize,"readFileAll() file size");
+    try {
+        out_mem.realloc(dataSize);
+    } catch (...) {
+        _checkf(false,"readFileAll() memory alloc");
+    }
+    _checkf(file.base.read(&file.base,0,out_mem.data(),out_mem.data_end()),"readFileAll() file read");
+clear:
+    _isInClear=hpatch_TRUE;
+    _checkf(hpatch_TFileStreamInput_close(&file),"readFileAll() file close");
+    return result;
+}
+
+
+#if (_IS_NEED_VCDIFF)
+static hpatch_BOOL getVcDiffDecompressPlugin(hpatch_TDecompress* out_decompressPlugin,
+                                             const hpatch_VcDiffInfo* vcdInfo){
+    const hpatch_TDecompress* decompressPlugin=0;
+    memset(out_decompressPlugin,0,sizeof(*out_decompressPlugin));
+
+    switch (vcdInfo->compressorID){
+        case 0: return hpatch_TRUE;
+#ifdef _CompressPlugin_7zXZ
+        case kVcDiff_compressorID_7zXZ:{
+            _init_CompressPlugin_7zXZ();
+            if (vcdInfo->isHDiffzAppHead_a)
+                decompressPlugin=&_7zXZDecompressPlugin_a;
+            else
+                decompressPlugin=&_7zXZDecompressPlugin;
+        } break;
+#endif
+        default: return hpatch_FALSE; //unsupport
+    }
+    if (decompressPlugin){
+        *out_decompressPlugin=*decompressPlugin;
+        out_decompressPlugin->decError=hpatch_dec_ok;
+    }
+    return hpatch_TRUE;
+}
+
+#ifdef _CompressPlugin_7zXZ
+#define _CompressPluginForVcDiff(vcdiffCompressPlugin,compressPlugin) \
+    vcdiff_TCompress _vcdiffCompressPlugin; \
+    vcdiffCompressPlugin=0; \
+    if (compressPlugin){ \
+        check(0==strcmp(compressPlugin->compressType(),"7zXZ"),HDIFF_OPTIONS_ERROR,"-VCD unsupport compressType"); \
+        _vcdiffCompressPlugin.compress_type=kVcDiff_compressorID_7zXZ; \
+        _vcdiffCompressPlugin.compress=compressPlugin; \
+        _vcdiffCompressPlugin.compress_open=_7zXZ_compress_open; \
+        _vcdiffCompressPlugin.compress_encode=_7zXZ_compress_encode; \
+        _vcdiffCompressPlugin.compress_close=_7zXZ_compress_close; \
+        vcdiffCompressPlugin=&_vcdiffCompressPlugin; }
+#else
+#define _CompressPluginForVcDiff(vcdiffCompressPlugin,compressPlugin) \
+    vcdiffCompressPlugin=0; \
+    if (compressPlugin){ \
+        check(hpatch_FALSE,HDIFF_OPTIONS_ERROR,"-VCD unsupport compress"); }
+#endif
+
+#endif //_IS_NEED_VCDIFF
+
+#define _check_on_error(errorType) { \
+    if (result==HDIFF_SUCCESS) result=errorType; if (!_isInClear){ goto clear; } }
+#define check(value,errorType,errorInfo) { if (!(value)){ \
+    hpatch_printStdErrPath_utf8((std::string()+errorInfo+" ERROR!\n").c_str()); \
+    _check_on_error(errorType); } }
+
+static int hdiff_in_mem(const char* oldFileName,const char* newFileName,const char* outDiffFileName,
+                        const hdiff_TCompress* compressPlugin,const TDiffSets& diffSets){
+    double diff_time0=clock_s();
+    int    result=HDIFF_SUCCESS;
+    int    _isInClear=hpatch_FALSE;
+    hpatch_TFileStreamOutput diffData_out;
+    hpatch_TFileStreamOutput_init(&diffData_out);
+    hdiff_private::TAutoMem oldMem(0);
+    hdiff_private::TAutoMem newMem(0);
+    if (oldFileName&&(strlen(oldFileName)>0))
+        check(readFileAll(oldMem,oldFileName),HDIFF_OPENREAD_ERROR,"open oldFile");
+    check(readFileAll(newMem,newFileName),HDIFF_OPENREAD_ERROR,"open newFile");
+    printf("oldDataSize : %" PRIu64 "\nnewDataSize : %" PRIu64 "\n",
+           (hpatch_StreamPos_t)oldMem.size(),(hpatch_StreamPos_t)newMem.size());
+    if (diffSets.isDoDiff){
+        if (diffSets.isCheckNotEqual)
+            check((oldMem.size()!=newMem.size())||(0!=memcmp(oldMem.data(),newMem.data(),oldMem.size())),
+                HDIFF_OLD_NEW_SAME_ERROR,"oldFile & newFile's datas can't be equal");
+        check(hpatch_TFileStreamOutput_open(&diffData_out,outDiffFileName,hpatch_kNullStreamPos),
+                HDIFF_OPENWRITE_ERROR,"open out diffFile");
+        hpatch_TFileStreamOutput_setRandomOut(&diffData_out,hpatch_TRUE);
+        try {
+#if (_IS_NEED_BSDIFF)
+            if (diffSets.isBsDiff){
+                create_bsdiff_block(newMem.data(),newMem.data_end(),oldMem.data(),oldMem.data_end(),&diffData_out.base,
+                                    compressPlugin,diffSets.isSingleCompressedDiff,(int)diffSets.matchScore,
+                                    diffSets.isUseBigCacheMatch,diffSets.matchBlockSize,diffSets.threadNum);   
+            }else
+#endif
+#if (_IS_NEED_VCDIFF)
+            if (diffSets.isVcDiff){
+                vcdiff_TCompress* vcdiffCompressPlugin;
+                _CompressPluginForVcDiff(vcdiffCompressPlugin,compressPlugin);
+                create_vcdiff_block(newMem.data(),newMem.data_end(),oldMem.data(),oldMem.data_end(),&diffData_out.base,
+                                    vcdiffCompressPlugin,(int)diffSets.matchScore,diffSets.isUseBigCacheMatch,
+                                    diffSets.matchBlockSize,diffSets.threadNum);   
+            }else
+#endif
+            if (diffSets.isSingleCompressedDiff){
+                create_single_compressed_diff_block(newMem.data(),newMem.data_end(),oldMem.data(),oldMem.data_end(),
+                                                    &diffData_out.base,compressPlugin,(int)diffSets.matchScore,
+                                                    diffSets.patchStepMemSize,diffSets.isUseBigCacheMatch,
+                                                    diffSets.matchBlockSize,diffSets.threadNum);     
+            }else{
+                create_compressed_diff_block(newMem.data(),newMem.data_end(),oldMem.data(),oldMem.data_end(),
+                                             &diffData_out.base,compressPlugin,(int)diffSets.matchScore,
+                                             diffSets.isUseBigCacheMatch,diffSets.matchBlockSize,diffSets.threadNum);
+            }
+            diffData_out.base.streamSize=diffData_out.out_length;
+        }catch(const std::exception& e){
+            check(!diffData_out.fileError,HDIFF_OPENWRITE_ERROR,"write diffFile");
+            check(false,HDIFF_DIFF_ERROR,"diff run error: "+e.what());
+        }
+        const hpatch_StreamPos_t outDiffDataSize=diffData_out.base.streamSize;
+        check(hpatch_TFileStreamOutput_close(&diffData_out),HDIFF_FILECLOSE_ERROR,"out diffFile close");
+        printf("diffDataSize: %" PRIu64 "\n",outDiffDataSize);
+        printf("diff    time: %.3f s\n",(clock_s()-diff_time0));
+        printf("  out diff file ok!\n");
+    }
+    if (diffSets.isDoPatchCheck){
+        hpatch_BOOL isSingleCompressedDiff=hpatch_FALSE;
+#if (_IS_NEED_BSDIFF)
+        hpatch_BOOL isBsDiff=hpatch_FALSE;
+        hpatch_BOOL isSingleCompressedBsDiff=hpatch_FALSE;
+#endif
+#if (_IS_NEED_VCDIFF)
+        hpatch_BOOL isVcDiff=hpatch_FALSE;
+#endif
+        hdiff_private::TAutoMem diffMem(0);
+        double patch_time0=clock_s();
+        printf("\nload diffFile for test by patch:\n");
+        check(readFileAll(diffMem,outDiffFileName),
+              HDIFF_OPENREAD_ERROR,"open diffFile for test");
+        printf("diffDataSize: %" PRIu64 "\n",(hpatch_StreamPos_t)diffMem.size());
+        
+        hpatch_TDecompress  _decompressPlugin={0};
+        hpatch_TDecompress* saved_decompressPlugin=&_decompressPlugin;
+        {
+            hpatch_compressedDiffInfo diffinfo;
+            hpatch_singleCompressedDiffInfo sdiffInfo;
+#if (_IS_NEED_VCDIFF)
+            hpatch_VcDiffInfo vcdiffInfo;
+#endif
+            const char* compressType="";
+            if (getCompressedDiffInfo_mem(&diffinfo,diffMem.data(),diffMem.data_end())){
+                compressType=diffinfo.compressType;
+            }else if (getSingleCompressedDiffInfo_mem(&sdiffInfo,diffMem.data(),diffMem.data_end())){
+                compressType=sdiffInfo.compressType;
+                isSingleCompressedDiff=hpatch_TRUE;
+                if (!diffSets.isDoDiff)
+                    printf("test single compressed diffData!\n");
+#if (_IS_NEED_BSDIFF)
+            }else if (getIsBsDiff_mem(diffMem.data(),diffMem.data_end(),&isSingleCompressedBsDiff)){
+                *saved_decompressPlugin=_bz2DecompressPlugin_unsz;
+                isBsDiff=hpatch_TRUE;
+                if (!diffSets.isDoDiff)
+                    printf(isSingleCompressedBsDiff?"test endsley/bsdiff's diffData!\n":"test bsdiff4's diffData!\n");
+#endif
+#if (_IS_NEED_VCDIFF)
+            }else if (getVcDiffInfo_mem(&vcdiffInfo,diffMem.data(),diffMem.data_end(),hpatch_FALSE)){
+                check(getVcDiffDecompressPlugin(saved_decompressPlugin,&vcdiffInfo),
+                      HDIFF_PATCH_ERROR,"VCDIFF unsported compressorID");
+                isVcDiff=hpatch_TRUE;
+                if (!diffSets.isDoDiff)
+                    printf("test VCDIFF's diffData!\n");
+#endif
+            }else{
+                check(hpatch_FALSE,HDIFF_PATCH_ERROR,"get diff info");
+            }
+            if (saved_decompressPlugin->open==0){
+                check(findDecompress(saved_decompressPlugin,compressType),
+                      HDIFF_PATCH_ERROR,"diff data saved compress type");
+            }
+            if (saved_decompressPlugin->open==0) saved_decompressPlugin=0;
+            else saved_decompressPlugin->decError=hpatch_dec_ok;
+        }
+        
+        bool diffrt;
+#if (_IS_NEED_BSDIFF)
+        if (isBsDiff)
+            diffrt=check_bsdiff(newMem.data(),newMem.data_end(),oldMem.data(),oldMem.data_end(),
+                                diffMem.data(),diffMem.data_end(),saved_decompressPlugin);
+        else
+#endif
+#if (_IS_NEED_VCDIFF)
+        if (isVcDiff)
+            diffrt=check_vcdiff(newMem.data(),newMem.data_end(),oldMem.data(),oldMem.data_end(),
+                                diffMem.data(),diffMem.data_end(),saved_decompressPlugin);
+        else
+#endif
+        if (isSingleCompressedDiff)
+            diffrt=check_single_compressed_diff(newMem.data(),newMem.data_end(),oldMem.data(),oldMem.data_end(),
+                                                diffMem.data(),diffMem.data_end(),saved_decompressPlugin);
+        else
+            diffrt=check_compressed_diff(newMem.data(),newMem.data_end(),oldMem.data(),oldMem.data_end(),
+                                         diffMem.data(),diffMem.data_end(),saved_decompressPlugin);
+        check(diffrt,HDIFF_PATCH_ERROR,"patch check diff data");
+        printf("patch   time: %.3f s\n",(clock_s()-patch_time0));
+        printf("  patch check diff data ok!\n");
+    }
+clear:
+    _isInClear=hpatch_TRUE;
+    check(hpatch_TFileStreamOutput_close(&diffData_out),HDIFF_FILECLOSE_ERROR,"out diffFile close");
+    return result;
+}
+
+static int hdiff_by_stream(const char* oldFileName,const char* newFileName,const char* outDiffFileName,
+                           const hdiff_TCompress* compressPlugin,const TDiffSets& diffSets){
+    double diff_time0=clock_s();
+    int result=HDIFF_SUCCESS;
+    int _isInClear=hpatch_FALSE;
+    hpatch_TFileStreamInput  oldData;
+    hpatch_TFileStreamInput  newData;
+    hpatch_TFileStreamOutput diffData_out;
+    hpatch_TFileStreamInput  diffData_in;
+    hpatch_TFileStreamInput_init(&oldData);
+    hpatch_TFileStreamInput_init(&newData);
+    hpatch_TFileStreamOutput_init(&diffData_out);
+    hpatch_TFileStreamInput_init(&diffData_in);
+    
+    if (oldFileName&&(strlen(oldFileName)>0)){
+        check(hpatch_TFileStreamInput_open(&oldData,oldFileName),HDIFF_OPENREAD_ERROR,"open oldFile");
+    }else{
+        mem_as_hStreamInput(&oldData.base,0,0);
+    }
+    check(hpatch_TFileStreamInput_open(&newData,newFileName),HDIFF_OPENREAD_ERROR,"open newFile");
+    printf("oldDataSize : %" PRIu64 "\nnewDataSize : %" PRIu64 "\n",
+           oldData.base.streamSize,newData.base.streamSize);
+    if (diffSets.isDoDiff){
+        if (diffSets.isCheckNotEqual)
+            check(!hdiff_streamDataIsEqual(&oldData.base,&newData.base),HDIFF_OLD_NEW_SAME_ERROR,"oldFile & newFile's datas can't be equal");
+        const hdiff_TMTSets_s mtsets={diffSets.threadNum,diffSets.threadNumSearch_s,false,false,false};
+        check(hpatch_TFileStreamOutput_open(&diffData_out,outDiffFileName,hpatch_kNullStreamPos),
+              HDIFF_OPENWRITE_ERROR,"open out diffFile");
+        hpatch_TFileStreamOutput_setRandomOut(&diffData_out,hpatch_TRUE);
+        try{
+#if (_IS_NEED_BSDIFF)
+            if (diffSets.isBsDiff){
+                create_bsdiff_stream(&newData.base,&oldData.base, &diffData_out.base,
+                                     compressPlugin,diffSets.isSingleCompressedDiff,
+                                     diffSets.matchBlockSize,&mtsets);   
+            }else
+#endif
+#if (_IS_NEED_VCDIFF)
+            if (diffSets.isVcDiff){
+                vcdiff_TCompress* vcdiffCompressPlugin;
+                _CompressPluginForVcDiff(vcdiffCompressPlugin,compressPlugin);
+                create_vcdiff_stream(&newData.base,&oldData.base, &diffData_out.base,
+                                     vcdiffCompressPlugin,diffSets.matchBlockSize,&mtsets);   
+            }else
+#endif
+            if (diffSets.isSingleCompressedDiff)
+                create_single_compressed_diff_stream(&newData.base,&oldData.base, &diffData_out.base,
+                                                     compressPlugin,diffSets.matchBlockSize,
+                                                     diffSets.patchStepMemSize,&mtsets);
+            else
+                create_compressed_diff_stream(&newData.base,&oldData.base, &diffData_out.base,
+                                              compressPlugin,diffSets.matchBlockSize,&mtsets);
+            diffData_out.base.streamSize=diffData_out.out_length;
+        }catch(const std::exception& e){
+            check(!newData.fileError,HDIFF_OPENREAD_ERROR,"read newFile");
+            check(!oldData.fileError,HDIFF_OPENREAD_ERROR,"read oldFile");
+            check(!diffData_out.fileError,HDIFF_OPENWRITE_ERROR,"write diffFile");
+            check(false,HDIFF_DIFF_ERROR,"stream diff run an error: "+e.what());
+        }
+        const hpatch_StreamPos_t outDiffDataSize=diffData_out.base.streamSize;
+        check(hpatch_TFileStreamOutput_close(&diffData_out),HDIFF_FILECLOSE_ERROR,"out diffFile close");
+        printf("diffDataSize: %" PRIu64 "\n",outDiffDataSize);
+        printf("diff    time: %.3f s\n",(clock_s()-diff_time0));
+        printf("  out diff file ok!\n");
+    }
+    if (diffSets.isDoPatchCheck){
+        double patch_time0=clock_s();
+        printf("\nload diffFile for test by patch check:\n");
+        check(hpatch_TFileStreamInput_open(&diffData_in,outDiffFileName),HDIFF_OPENREAD_ERROR,"open check diffFile");
+        printf("diffDataSize: %" PRIu64 "\n",diffData_in.base.streamSize);
+
+        hpatch_BOOL isSingleCompressedDiff=hpatch_FALSE;
+#if (_IS_NEED_BSDIFF)
+        hpatch_BOOL isBsDiff=hpatch_FALSE;
+        hpatch_BOOL isSingleCompressedBsDiff=hpatch_FALSE;
+#endif
+#if (_IS_NEED_VCDIFF)
+        hpatch_BOOL isVcDiff=hpatch_FALSE;
+#endif
+        hpatch_TDecompress  _decompressPlugin={0};
+        hpatch_TDecompress* saved_decompressPlugin=&_decompressPlugin;
+        {
+            hpatch_compressedDiffInfo diffInfo;
+            hpatch_singleCompressedDiffInfo sdiffInfo;
+#if (_IS_NEED_VCDIFF)
+            hpatch_VcDiffInfo vcdiffInfo;
+#endif
+            const char* compressType="";
+            if (getCompressedDiffInfo(&diffInfo,&diffData_in.base)){
+                compressType=diffInfo.compressType;
+            }else if (getSingleCompressedDiffInfo(&sdiffInfo,&diffData_in.base,0)){
+                compressType=sdiffInfo.compressType;
+                isSingleCompressedDiff=hpatch_TRUE;
+                if (!diffSets.isDoDiff)
+                    printf("test single compressed diffData!\n");
+#if (_IS_NEED_BSDIFF)
+            }else if (getIsBsDiff(&diffData_in.base,&isSingleCompressedBsDiff)){
+                *saved_decompressPlugin=_bz2DecompressPlugin_unsz;
+                isBsDiff=hpatch_TRUE;
+                if (!diffSets.isDoDiff)
+                    printf(isSingleCompressedBsDiff?"test endsley/bsdiff's diffData!\n":"test bsdiff4's diffData!\n");
+#endif
+#if (_IS_NEED_VCDIFF)
+            }else if (getVcDiffInfo(&vcdiffInfo,&diffData_in.base,hpatch_FALSE)){
+                check(getVcDiffDecompressPlugin(saved_decompressPlugin,&vcdiffInfo),
+                      HDIFF_PATCH_ERROR,"VCDIFF unsported compressorID");
+                isVcDiff=hpatch_TRUE;
+                if (!diffSets.isDoDiff)
+                    printf("test VCDIFF's diffData!\n");
+#endif
+            }else{
+                check(hpatch_FALSE,HDIFF_PATCH_ERROR,"get diff info");
+            }
+            if (saved_decompressPlugin->open==0){
+                check(findDecompress(saved_decompressPlugin,compressType),
+                      HDIFF_PATCH_ERROR,"diff data saved compress type");
+            }
+            if (saved_decompressPlugin->open==0) saved_decompressPlugin=0;
+            else saved_decompressPlugin->decError=hpatch_dec_ok;
+        }
+        bool diffrt;
+#if (_IS_NEED_BSDIFF)
+        if (isBsDiff)
+            diffrt=check_bsdiff(&newData.base,&oldData.base,&diffData_in.base,saved_decompressPlugin);
+        else
+#endif
+#if (_IS_NEED_VCDIFF)
+        if (isVcDiff)
+            diffrt=check_vcdiff(&newData.base,&oldData.base,&diffData_in.base,saved_decompressPlugin);
+        else
+#endif
+        if (isSingleCompressedDiff)
+            diffrt=check_single_compressed_diff(&newData.base,&oldData.base,&diffData_in.base,saved_decompressPlugin);
+        else
+            diffrt=check_compressed_diff(&newData.base,&oldData.base,&diffData_in.base,saved_decompressPlugin);
+        check(diffrt,HDIFF_PATCH_ERROR,"patch check diff data");
+        printf("patch   time: %.3f s\n",(clock_s()-patch_time0));
+        printf("  patch check diff data ok!\n");
+    }
+clear:
+    _isInClear=hpatch_TRUE;
+    check(hpatch_TFileStreamOutput_close(&diffData_out),HDIFF_FILECLOSE_ERROR,"out diffFile close");
+    check(hpatch_TFileStreamInput_close(&diffData_in),HDIFF_FILECLOSE_ERROR,"in diffFile close");
+    check(hpatch_TFileStreamInput_close(&newData),HDIFF_FILECLOSE_ERROR,"newFile close");
+    check(hpatch_TFileStreamInput_close(&oldData),HDIFF_FILECLOSE_ERROR,"oldFile close");
+    return result;
+}
+
+int hdiff(const char* oldFileName,const char* newFileName,const char* outDiffFileName,
+          const hdiff_TCompress* compressPlugin,const TDiffSets& diffSets){
+    double time0=clock_s();
+    std::string fnameInfo=std::string("old : \"")+oldFileName+"\"\n"
+                                     +"new : \""+newFileName+"\"\n"
+                             +(diffSets.isDoDiff?"out : \"":"test: \"")+outDiffFileName+"\"\n";
+    hpatch_printPath_utf8(fnameInfo.c_str());
+    
+    if (diffSets.isDoDiff) {
+        const char* compressTypeTxt="";
+        if (compressPlugin) compressTypeTxt=compressPlugin->compressTypeForDisplay?
+                                compressPlugin->compressTypeForDisplay():compressPlugin->compressType();
+        printf("hdiffz run with compress plugin: \"%s\"\n",compressTypeTxt);
+        if (diffSets.isSingleCompressedDiff){
+      #if (_IS_NEED_BSDIFF)
+          if (!diffSets.isBsDiff)
+      #endif
+            printf("create single compressed diffData!\n");
+        }
+#if (_IS_NEED_BSDIFF)
+        if (diffSets.isBsDiff)
+            printf(diffSets.isSingleCompressedDiff?"create endsley/bsdiff diffData!\n":"create bsdiff4 diffData!\n");
+#endif
+#if (_IS_NEED_VCDIFF)
+        if (diffSets.isVcDiff)
+            printf("create VCDIFF diffData!\n");
+#endif
+    }
+    
+    int exitCode;
+    if (diffSets.isDiffInMem)
+        exitCode=hdiff_in_mem(oldFileName,newFileName,outDiffFileName,
+                              compressPlugin,diffSets);
+    else
+        exitCode=hdiff_by_stream(oldFileName,newFileName,outDiffFileName,
+                                 compressPlugin,diffSets);
+    if (diffSets.isDoDiff && diffSets.isDoPatchCheck)
+        printf("\nall   time: %.3f s\n",(clock_s()-time0));
+    return exitCode;
+}
+
+int hdiff_resave(const char* diffFileName,const char* outDiffFileName,
+                 const hdiff_TCompress* compressPlugin){
+    double time0=clock_s();
+    std::string fnameInfo=std::string("in_diff : \"")+diffFileName+"\"\n"
+        +"out_diff: \""+outDiffFileName+"\"\n";
+    hpatch_printPath_utf8(fnameInfo.c_str());
+    
+    int result=HDIFF_SUCCESS;
+    hpatch_BOOL  _isInClear=hpatch_FALSE;
+    hpatch_BOOL  isDirDiff=hpatch_FALSE;
+    hpatch_BOOL  isSingleDiff=hpatch_FALSE;
+    hpatch_compressedDiffInfo diffInfo;
+    hpatch_singleCompressedDiffInfo singleDiffInfo;
+#if (_IS_NEED_DIR_DIFF_PATCH)
+    std::string  dirCompressType;
+    TDirDiffInfo dirDiffInfo;
+    hpatch_TChecksum* checksumPlugin=0;
+#endif
+    hpatch_TFileStreamInput  diffData_in;
+    hpatch_TFileStreamOutput diffData_out;
+    hpatch_TFileStreamInput_init(&diffData_in);
+    hpatch_TFileStreamOutput_init(&diffData_out);
+    
+    hpatch_TDecompress _decompressPlugin={0};
+    hpatch_TDecompress* decompressPlugin=&_decompressPlugin;
+    check(hpatch_TFileStreamInput_open(&diffData_in,diffFileName),HDIFF_OPENREAD_ERROR,"open diffFile");
+#if (_IS_NEED_DIR_DIFF_PATCH)
+    check(getDirDiffInfo(&dirDiffInfo,&diffData_in.base),HDIFF_OPENREAD_ERROR,"read diffFile");
+    isDirDiff=dirDiffInfo.isDirDiff;
+    if (isDirDiff){
+        diffInfo=dirDiffInfo.hdiffInfo;
+        diffInfo.compressedCount+=dirDiffInfo.dirDataIsCompressed?1:0;
+        printf("  resave as dir diffFile \n");
+    }else
+#endif
+    if (getSingleCompressedDiffInfo(&singleDiffInfo,&diffData_in.base,0)){
+        isSingleDiff=hpatch_TRUE;
+        _singleDiffInfoToHDiffInfo(&diffInfo,&singleDiffInfo);
+        printf("  resave as single stream diffFile \n");
+    }else if(getCompressedDiffInfo(&diffInfo,&diffData_in.base)){
+        //ok
+    }else{
+        check(!diffData_in.fileError,HDIFF_RESAVE_FILEREAD_ERROR,"read diffFile");
+        check(hpatch_FALSE,HDIFF_RESAVE_DIFFINFO_ERROR,"is hdiff file? get diff info");
+    }
+    {//decompressPlugin
+        findDecompress(decompressPlugin,diffInfo.compressType);
+        if (decompressPlugin->open==0){
+            if (diffInfo.compressedCount>0){
+                check(false,HDIFF_RESAVE_COMPRESSTYPE_ERROR,
+                      "can no decompress \""+diffInfo.compressType+" data");
+            }else{
+                if (strlen(diffInfo.compressType)>0)
+                    printf("  diffFile added useless compress tag \"%s\"\n",diffInfo.compressType);
+                decompressPlugin=0;
+            }
+        }else{
+            decompressPlugin->decError=hpatch_dec_ok;
+            printf("resave diffFile with decompress plugin: \"%s\" (need decompress %d)\n",diffInfo.compressType,diffInfo.compressedCount);
+        }
+    }
+    {
+        const char* compressTypeTxt="";
+        if (compressPlugin) compressTypeTxt=compressPlugin->compressTypeForDisplay?
+                                compressPlugin->compressTypeForDisplay():compressPlugin->compressType();
+        printf("resave diffFile with compress plugin: \"%s\"\n",compressTypeTxt);
+    }
+#if (_IS_NEED_DIR_DIFF_PATCH)
+    if (isDirDiff){ //checksumPlugin
+        if (strlen(dirDiffInfo.checksumType)>0){
+            check(findChecksum(&checksumPlugin,dirDiffInfo.checksumType), HDIFF_RESAVE_CHECKSUMTYPE_ERROR,
+                  "not found checksum plugin dirDiffFile used: \""+dirDiffInfo.checksumType+"\"\n");
+            check(checksumPlugin->checksumByteSize()==dirDiffInfo.checksumByteSize,HDIFF_RESAVE_CHECKSUMTYPE_ERROR,
+                  "found checksum plugin not same as dirDiffFile used: \""+dirDiffInfo.checksumType+"\"\n");
+        }
+        printf("resave dirDiffFile with checksum plugin: \"%s\"\n",dirDiffInfo.checksumType);
+    }else{
+        _options_check(checksumPlugin==0,"-C now only support dir diff");
+    }
+#endif
+
+    check(hpatch_TFileStreamOutput_open(&diffData_out,outDiffFileName,hpatch_kNullStreamPos),HDIFF_OPENWRITE_ERROR,
+          "open out diffFile");
+    hpatch_TFileStreamOutput_setRandomOut(&diffData_out,hpatch_TRUE);
+    printf("inDiffSize : %" PRIu64 "\n",diffData_in.base.streamSize);
+    try{
+#if (_IS_NEED_DIR_DIFF_PATCH)
+        if (isDirDiff){
+            resave_dirdiff(&diffData_in.base,decompressPlugin,
+                           &diffData_out.base,compressPlugin,checksumPlugin);
+        }else
+#endif
+        if (isSingleDiff)
+            resave_single_compressed_diff(&diffData_in.base,decompressPlugin,
+                                          &diffData_out.base,compressPlugin,&singleDiffInfo);
+        else
+            resave_compressed_diff(&diffData_in.base,decompressPlugin,
+                                   &diffData_out.base,compressPlugin);
+        diffData_out.base.streamSize=diffData_out.out_length;
+    }catch(const std::exception& e){
+        check(!diffData_in.fileError,HDIFF_RESAVE_FILEREAD_ERROR,"read diffFile");
+        check(!diffData_out.fileError,HDIFF_RESAVE_OPENWRITE_ERROR,"write diffFile");
+        check(false,HDIFF_RESAVE_ERROR,"resave diff run an error: "+e.what());
+    }
+    printf("outDiffSize: %" PRIu64 "\n",diffData_out.base.streamSize);
+    check(hpatch_TFileStreamOutput_close(&diffData_out),HDIFF_FILECLOSE_ERROR,"out diffFile close");
+    printf("  out diff file ok!\n");
+    
+    printf("\nhdiffz resave diffFile time: %.3f s\n",(clock_s()-time0));
+clear:
+    _isInClear=hpatch_TRUE;
+    check(hpatch_TFileStreamOutput_close(&diffData_out),HDIFF_FILECLOSE_ERROR,"out diffFile close");
+    check(hpatch_TFileStreamInput_close(&diffData_in),HDIFF_FILECLOSE_ERROR,"in diffFile close");
+    return result;
+}
+
+
+#if (_IS_NEED_DIR_DIFF_PATCH)
+
+struct DirPathIgnoreListener:public CDirPathIgnore,IDirPathIgnore{
+    DirPathIgnoreListener(const std::vector<std::string>& ignorePathListBase,
+                          const std::vector<std::string>& ignorePathList,bool isPrintIgnore=true)
+    :CDirPathIgnore(ignorePathListBase,ignorePathList,isPrintIgnore){}
+    //IDirPathIgnore
+    virtual bool isNeedIgnore(const std::string& path,size_t rootPathNameLen){
+        return CDirPathIgnore::isNeedIgnore(path,rootPathNameLen);
+    }
+};
+
+struct DirDiffListener:public IDirDiffListener{
+    virtual bool isExecuteFile(const std::string& fileName) {
+        bool result= 0!=hpatch_getIsExecuteFile(fileName.c_str());
+        if (result){
+            std::string info="  got new file Execute tag:\""+fileName+"\"\n";
+            hpatch_printPath_utf8(info.c_str());
+        }
+        return result;
+    }
+    virtual void diffRefInfo(size_t oldPathCount,size_t newPathCount,size_t sameFilePairCount,
+                             hpatch_StreamPos_t sameFileSize,size_t refOldFileCount,size_t refNewFileCount,
+                             hpatch_StreamPos_t refOldFileSize,hpatch_StreamPos_t refNewFileSize){
+        printf("      old path count: %" PRIu64 "\n",(hpatch_StreamPos_t)oldPathCount);
+        printf("      new path count: %" PRIu64 " (fileCount:%" PRIu64 ")\n",
+               (hpatch_StreamPos_t)newPathCount,(hpatch_StreamPos_t)(sameFilePairCount+refNewFileCount));
+        printf("     same file count: %" PRIu64 " (dataSize: %" PRIu64 ")\n",
+               (hpatch_StreamPos_t)sameFilePairCount,sameFileSize);
+        printf("  ref old file count: %" PRIu64 "\n",(hpatch_StreamPos_t)refOldFileCount);
+        printf(" diff new file count: %" PRIu64 "\n",(hpatch_StreamPos_t)refNewFileCount);
+        printf("\nrun hdiffz:\n");
+        printf("  oldRefSize  : %" PRIu64 "\n",refOldFileSize);
+        printf("  newRefSize  : %" PRIu64 " (all newSize: %" PRIu64 ")\n",refNewFileSize,refNewFileSize+sameFileSize);
+    }
+    
+    double _runHDiffBegin_time0;
+    virtual void runHDiffBegin(){ _runHDiffBegin_time0=clock_s(); }
+    virtual void runHDiffEnd(hpatch_StreamPos_t diffDataSize){
+        printf("  diffDataSize: %" PRIu64 "\n",diffDataSize);
+        printf("  diff    time: %.3f s\n",clock_s()-_runHDiffBegin_time0);
+    }
+};
+
+static void check_manifest(TManifest& out_manifest,const std::string& rootPath,const std::string& manifestFileName){
+    TManifestSaved  manifest;
+    load_manifestFile(manifest,rootPath,manifestFileName);
+    hpatch_TChecksum* checksumPlugin=0;
+    findChecksum(&checksumPlugin,manifest.checksumType.c_str());
+    checksum_manifest(manifest,checksumPlugin);
+    out_manifest.rootPath.swap(manifest.rootPath);
+    out_manifest.pathList.swap(manifest.pathList);
+}
+
+int hdiff_dir(const char* _oldPath,const char* _newPath,const char* outDiffFileName,
+              const hdiff_TCompress* compressPlugin,hpatch_TChecksum* checksumPlugin,
+              hpatch_BOOL oldIsDir, hpatch_BOOL newIsDir,
+              const TDiffSets& diffSets,size_t kMaxOpenFileNumber,
+              const std::vector<std::string>& ignorePathListBase,const std::vector<std::string>& ignoreOldPathList,
+              const std::vector<std::string>& ignoreNewPathList,
+              const std::string& oldManifestFileName,const std::string& newManifestFileName){
+    double time0=clock_s();
+    std::string oldPath(_oldPath);
+    std::string newPath(_newPath);
+    if (oldIsDir) assignDirTag(oldPath); else assert(!hpatch_getIsDirName(oldPath.c_str()));
+    if (newIsDir) assignDirTag(newPath); else assert(!hpatch_getIsDirName(newPath.c_str()));
+    std::string fnameInfo=std::string("")
+        +(oldIsDir?"oldDir : \"":"oldFile: \"")+oldPath+"\"\n"
+        +(newIsDir?"newDir : \"":"newFile: \"")+newPath+"\"\n"
+        +(diffSets.isDoDiff ?  "outDiff: \"":"  test : \"")+outDiffFileName+"\"\n";
+    hpatch_printPath_utf8(fnameInfo.c_str());
+    
+    bool isManifest= (!newManifestFileName.empty());
+    if (diffSets.isDoDiff) {
+        const char* checksumType="";
+        const char* compressTypeTxt="";
+        if (checksumPlugin)
+            checksumType=checksumPlugin->checksumType();
+        if (compressPlugin) compressTypeTxt=compressPlugin->compressTypeForDisplay?
+                                compressPlugin->compressTypeForDisplay():compressPlugin->compressType();
+        printf("hdiffz run %sdir diff with compress plugin: \"%s\"\n",isManifest?"manifest ":"",compressTypeTxt);
+        printf("hdiffz run %sdir diff with checksum plugin: \"%s\"\n",isManifest?"manifest ":"",checksumType);
+    }
+    printf("\n");
+    
+    int  result=HDIFF_SUCCESS;
+    bool _isInClear=false;
+    hpatch_TFileStreamOutput diffData_out;
+    hpatch_TFileStreamInput diffData_in;
+    hpatch_TFileStreamOutput_init(&diffData_out);
+    hpatch_TFileStreamInput_init(&diffData_in);
+    
+    TManifest   oldManifest;
+    TManifest   newManifest;
+    if (isManifest){
+        double check_time0=clock_s();
+        try {
+            if (!oldPath.empty())// isOldPathInputEmpty
+                check_manifest(oldManifest,oldPath,oldManifestFileName);
+            check_manifest(newManifest,newPath,newManifestFileName);
+        }catch(const std::exception& e){
+            check(false,MANIFEST_TEST_ERROR,"check by manifest found an error: "+e.what());
+        }
+        printf("check manifest time: %.3f s\n",(clock_s()-check_time0));
+        printf("  check path datas by manifest ok!\n\n");
+    }else{
+        DirPathIgnoreListener oldDirPathIgnore(ignorePathListBase,ignoreOldPathList);
+        DirPathIgnoreListener newDirPathIgnore(ignorePathListBase,ignoreNewPathList);
+        get_manifest(&oldDirPathIgnore,oldPath,oldManifest);
+        get_manifest(&newDirPathIgnore,newPath,newManifest);
+    }
+
+    if (diffSets.isDoDiff){
+        double diff_time0=clock_s();
+        try {
+            check(hpatch_TFileStreamOutput_open(&diffData_out,outDiffFileName,hpatch_kNullStreamPos),
+                  HDIFF_OPENWRITE_ERROR,"open out diffFile");
+            hpatch_TFileStreamOutput_setRandomOut(&diffData_out,hpatch_TRUE);
+            DirDiffListener listener;
+            dir_diff(&listener,oldManifest,newManifest,&diffData_out.base,
+                     compressPlugin,checksumPlugin,diffSets,kMaxOpenFileNumber);
+            diffData_out.base.streamSize=diffData_out.out_length;
+        }catch(const std::exception& e){
+            check(false,DIRDIFF_DIFF_ERROR,"dir diff run an error: "+e.what());
+        }
+        printf("\ndiffDataSize  : %" PRIu64 "\n",diffData_out.base.streamSize);
+        printf("dir  diff time: %.3f s\n",(clock_s()-diff_time0));
+        check(hpatch_TFileStreamOutput_close(&diffData_out),HDIFF_FILECLOSE_ERROR,"out diffFile close");
+        printf("  out dirDiffFile ok!\n");
+    }
+    if (diffSets.isDoPatchCheck){
+        double patch_time0=clock_s();
+        printf("\nload %sdirDiffFile for test by patch check:\n",isManifest?"manifest ":"");
+        check(hpatch_TFileStreamInput_open(&diffData_in,outDiffFileName),
+              HDIFF_OPENREAD_ERROR,"open check diffFile");
+        printf("diffDataSize  : %" PRIu64 "\n",diffData_in.base.streamSize);
+        hpatch_TDecompress _decompressPlugin={0};
+        hpatch_TDecompress* saved_decompressPlugin=&_decompressPlugin;
+        hpatch_TChecksum* saved_checksumPlugin=0;
+        {
+            TDirDiffInfo dirinfo;
+            check(getDirDiffInfo(&dirinfo,&diffData_in.base),DIRDIFF_PATCH_ERROR,"get dir diff info");
+            check(dirinfo.isDirDiff,DIRDIFF_PATCH_ERROR,"dir diffFile data");
+            check(findDecompress(saved_decompressPlugin,dirinfo.hdiffInfo.compressType),
+                  DIRDIFF_PATCH_ERROR,"diff data saved compress type");
+            if (saved_decompressPlugin->open==0) saved_decompressPlugin=0;
+            else saved_decompressPlugin->decError=hpatch_dec_ok;
+            check(findChecksum(&saved_checksumPlugin,dirinfo.checksumType),
+                  DIRDIFF_PATCH_ERROR,"diff data saved checksum type");
+            
+        }
+        //check(check_dirOldDataChecksum(oldPath.c_str(),&diffData_in.base,
+        //      saved_decompressPlugin,saved_checksumPlugin),
+        //      DIRDIFF_PATCH_ERROR,"part diff data check_dirOldDataChecksum");
+        DirDiffListener listener;
+        check(check_dirdiff(&listener,oldManifest,newManifest,&diffData_in.base,
+                            saved_decompressPlugin,saved_checksumPlugin,kMaxOpenFileNumber),
+              DIRDIFF_PATCH_ERROR,"dir patch check diff data");
+
+        printf("dir patch time: %.3f s\n",(clock_s()-patch_time0));
+        printf("  patch check diff data ok!\n");
+    }
+    
+    printf("\nall   time: %.3f s\n",(clock_s()-time0));
+clear:
+    _isInClear=true;
+    check(hpatch_TFileStreamOutput_close(&diffData_out),HDIFF_FILECLOSE_ERROR,"out diffFile close");
+    check(hpatch_TFileStreamInput_close(&diffData_in),HDIFF_FILECLOSE_ERROR,"in diffFile close");
+    return result;
+}
+
+int create_manifest(const char* _inputPath,const char* outManifestFileName,
+                    hpatch_TChecksum* checksumPlugin,const std::vector<std::string>& ignorePathList){
+    double time0=clock_s();
+    int  result=HDIFF_SUCCESS;
+    bool _isInClear=false;
+    std::string inputPath(_inputPath);
+    {
+        hpatch_TPathType inputType;
+        check(hpatch_getPathStat(_inputPath,&inputType,0),HDIFF_PATHTYPE_ERROR,"get inputPath type");
+        check((inputType!=kPathType_notExist),HDIFF_PATHTYPE_ERROR,"inputPath not exist");
+        hpatch_BOOL inputIsDir=(inputType==kPathType_dir);
+        if (inputIsDir) assignDirTag(inputPath);
+        std::string fnameInfo=std::string("")
+            +(inputIsDir? "inputDir   : \"":"inputFile:   \"")+inputPath+"\"\n"
+                        + "outManifest: \""+outManifestFileName+"\"\n";
+        hpatch_printPath_utf8(fnameInfo.c_str());
+    }
+    {
+        const char* checksumType="";
+        if (checksumPlugin) checksumType=checksumPlugin->checksumType();
+        printf("hdiffz run create Manifest with checksum plugin: \"%s\"\n",checksumType);
+        printf("\n");
+    }
+    
+    hpatch_TFileStreamOutput manifestData_out;
+    hpatch_TFileStreamOutput_init(&manifestData_out);
+    {//create
+        try {
+            std::vector<std::string> emptyPathList;
+            check(hpatch_TFileStreamOutput_open(&manifestData_out,outManifestFileName,hpatch_kNullStreamPos),
+                  HDIFF_OPENWRITE_ERROR,"open out manifestFile");
+            //hpatch_TFileStreamOutput_setRandomOut(&manifestData_out,hpatch_TRUE);
+            DirPathIgnoreListener dirPathIgnore(ignorePathList,emptyPathList);
+            save_manifest(&dirPathIgnore,inputPath,&manifestData_out.base,checksumPlugin);
+            manifestData_out.base.streamSize=manifestData_out.out_length;
+        }catch(const std::exception& e){
+            check(false,MANIFEST_CREATE_ERROR,"create manifest run an error: "+e.what());
+        }
+        printf("\nManifestFile size: %" PRIu64 "\n",manifestData_out.base.streamSize);
+        check(hpatch_TFileStreamOutput_close(&manifestData_out),HDIFF_FILECLOSE_ERROR,"check manifestFile close");
+        printf("  out manifestFile ok!\n");
+        printf("create manifest time: %.3f s\n",(clock_s()-time0));
+    }
+    {//test
+        double time1=clock_s();
+        TManifest    manifest;
+        try {
+            check_manifest(manifest,inputPath,outManifestFileName);
+        }catch(const std::exception& e){
+            check(false,MANIFEST_TEST_ERROR,"test manifestFile found an error: "+e.what());
+        }
+        printf("  test manifestFile ok!\n");
+        printf("test   manifest time: %.3f s\n",(clock_s()-time1));
+    }
+    
+    printf("\nall   time: %.3f s\n",(clock_s()-time0));
+clear:
+    _isInClear=true;
+    check(hpatch_TFileStreamOutput_close(&manifestData_out),HDIFF_FILECLOSE_ERROR,"check manifestFile close");
+    return result;
+}
+#endif //_IS_NEED_DIR_DIFF_PATCH