react-native-update 10.60.0 → 10.61.0

package/android/jni/HDiffPatch/hpatchz.c

@@ -1,1221 +0,0 @@
-//hpatchz.c
-// patch tool
-//
-/*
- This is the HDiffPatch copyright.
-
- Copyright (c) 2012-2019 HouSisong All Rights Reserved.
-
- 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 <string.h>
-#include <stdlib.h>
-#include <stdio.h>  //fprintf
-#include "libHDiffPatch/HPatch/patch.h"
-#include "_clock_for_demo.h"
-#include "_atosize.h"
-#include "file_for_patch.h"
-
-#if (_IS_NEED_DIR_DIFF_PATCH)
-#include "dirDiffPatch/dir_patch/dir_patch.h"
-#include "hpatch_dir_listener.h"
-#endif
-
-#ifndef _IS_NEED_MAIN
-#   define  _IS_NEED_MAIN 1
-#endif
-#ifndef _IS_NEED_SFX
-#   define _IS_NEED_SFX 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
-#   define _CompressPlugin_bz2
-#   define _CompressPlugin_lzma
-#   define _CompressPlugin_lzma2
-#endif
-#if (_IS_NEED_ALL_CompressPlugin)
-//===== select needs decompress plugins or change to your plugin=====
-#   define _CompressPlugin_lz4 // || _CompressPlugin_lz4hc
-#   define _CompressPlugin_zstd
-#   define _CompressPlugin_brotli
-#   define _CompressPlugin_lzham
-#endif
-
-#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 effective
-#endif
-
-
-#include "checksum_plugin_demo.h"
-#endif
-
-static void printVersion(){
-    printf("HDiffPatch::hpatchz v" HDIFFPATCH_VERSION_STRING "\n\n");
-}
-
-static void printUsage(){
-    printVersion();
-    printf("patch usage: hpatchz [options] oldPath diffFile outNewPath\n"
-#if (_IS_NEED_SFX)
-           "create  SFX: hpatchz [-X-exe#selfExecuteFile] diffFile -X#outSelfExtractArchive\n"
-           "run     SFX: selfExtractArchive [[options] oldPath -X outNewPath]\n"
-           "extract SFX: selfExtractArchive      (same as: selfExtractArchive -f \"\" -X "
-#   ifdef _WIN32
-           "\".\\\")\n"
-#   else
-           "\"./\")\n"
-#   endif
-#endif
-           "  if oldPath is empty input parameter \"\"\n"
-           "memory options:\n"
-           "  -m  oldPath all loaded into Memory;\n"
-           "      requires (oldFileSize+ 4*decompress stream size)+O(1) bytes of memory.\n"
-           "  -s[-cacheSize] \n"
-           "      DEFAULT -s-64m; oldPath loaded as Stream;\n"
-           "      requires (cacheSize+ 4*decompress stream size)+O(1) bytes of memory;\n"
-           "      cacheSize can like 262144 or 256k or 512m or 2g etc....\n"
-           "special options:\n"
-#if (_IS_NEED_DIR_DIFF_PATCH)
-           "  -C-checksumSets\n"
-           "      set Checksum data for directory patch, DEFAULT -C-new-copy;\n"
-           "      checksumSets support (can choose multiple):\n"
-           "        -C-diff         checksum diffFile;\n"
-           "        -C-old          checksum old reference files;\n"
-           "        -C-new          checksum new files edited from old reference files;\n"
-           "        -C-copy         checksum new files copy from old same files;\n"
-           "        -C-no           no checksum;\n"
-           "        -C-all          same as: -C-diff-old-new-copy;\n"
-           "  -n-maxOpenFileNumber\n"
-           "      limit Number of open files at same time when stream directory patch;\n"
-           "      maxOpenFileNumber>=8, DEFAULT -n-24, the best limit value by different\n"
-           "        operating system.\n"
-#endif
-           "  -f  Force overwrite, ignore write path already exists;\n"
-           "      DEFAULT (no -f) not overwrite and then return error;\n"
-           "      support oldPath outNewPath same path!(patch to tempPath and overwrite old)\n"
-           "      if used -f and outNewPath is exist file:\n"
-#if (_IS_NEED_DIR_DIFF_PATCH)
-           "        if patch output file, will overwrite;\n"
-#else
-           "        will overwrite;\n"
-#endif
-#if (_IS_NEED_DIR_DIFF_PATCH)
-           "        if patch output directory, will always return error;\n"
-#endif
-           "      if used -f and outNewPath is exist directory:\n"
-#if (_IS_NEED_DIR_DIFF_PATCH)
-           "        if patch output file, will always return error;\n"
-#else
-           "        will always return error;\n"
-#endif
-#if (_IS_NEED_DIR_DIFF_PATCH)
-           "        if patch output directory, will overwrite, but not delete\n"
-           "          needless existing files in directory.\n"
-#endif
-           "  -h or -?\n"
-           "      output Help info (this usage).\n"
-           "  -v  output Version info.\n\n"
-           );
-}
-
-typedef enum THPatchResult {
-    HPATCH_SUCCESS=0,
-    HPATCH_OPTIONS_ERROR,
-    HPATCH_OPENREAD_ERROR,
-    HPATCH_OPENWRITE_ERROR,
-    HPATCH_FILEREAD_ERROR,
-    HPATCH_FILEWRITE_ERROR, // 5
-    HPATCH_FILEDATA_ERROR,
-    HPATCH_FILECLOSE_ERROR,
-    HPATCH_MEM_ERROR,
-    HPATCH_HDIFFINFO_ERROR,
-    HPATCH_COMPRESSTYPE_ERROR, // 10
-    HPATCH_PATCH_ERROR,
-    
-    HPATCH_PATHTYPE_ERROR, //adding begin v3.0
-    HPATCH_TEMPPATH_ERROR,
-    HPATCH_DELETEPATH_ERROR,
-    HPATCH_RENAMEPATH_ERROR, // 15
-
-#if (_IS_NEED_DIR_DIFF_PATCH)
-    DIRPATCH_DIRDIFFINFO_ERROR=101,
-    DIRPATCH_CHECKSUMTYPE_ERROR,
-    DIRPATCH_CHECKSUMSET_ERROR,
-    DIRPATCH_CHECKSUM_DIFFDATA_ERROR,
-    DIRPATCH_CHECKSUM_OLDDATA_ERROR, // 105
-    DIRPATCH_CHECKSUM_NEWDATA_ERROR,
-    DIRPATCH_CHECKSUM_COPYDATA_ERROR,
-    DIRPATCH_PATCH_ERROR,
-    DIRPATCH_LAOD_DIRDIFFDATA_ERROR,
-    DIRPATCH_OPEN_OLDPATH_ERROR, // 110
-    DIRPATCH_OPEN_NEWPATH_ERROR,
-    DIRPATCH_CLOSE_OLDPATH_ERROR,
-    DIRPATCH_CLOSE_NEWPATH_ERROR,
-    DIRPATCH_PATCHBEGIN_ERROR,
-    DIRPATCH_PATCHFINISH_ERROR, // 115
-#endif
-#if (_IS_NEED_SFX)
-    HPATCH_CREATE_SFX_DIFFFILETYPE_ERROR=201,
-    HPATCH_CREATE_SFX_SFXTYPE_ERROR,
-    HPATCH_CREATE_SFX_EXECUTETAG_ERROR,
-    HPATCH_RUN_SFX_NOTSFX_ERROR,
-    HPATCH_RUN_SFX_DIFFOFFSERT_ERROR, // 205
-#endif
-} THPatchResult;
-
-int hpatch_cmd_line(int argc, const char * argv[]);
-
-int hpatch(const char* oldFileName,const char* diffFileName,const char* outNewFileName,
-           hpatch_BOOL isLoadOldAll,size_t patchCacheSize,
-           hpatch_StreamPos_t diffDataOffert,hpatch_StreamPos_t diffDataSize);
-#if (_IS_NEED_DIR_DIFF_PATCH)
-int hpatch_dir(const char* oldPath,const char* diffFileName,const char* outNewPath,
-               hpatch_BOOL isLoadOldAll,size_t patchCacheSize,size_t kMaxOpenFileNumber,
-               TDirPatchChecksumSet* checksumSet,IHPatchDirListener* hlistener,
-               hpatch_StreamPos_t diffDataOffert,hpatch_StreamPos_t diffDataSize);
-#endif
-#if (_IS_NEED_SFX)
-int createSfx(const char* selfExecuteFileName,const char* diffFileName,const char* out_sfxFileName);
-hpatch_BOOL getDiffDataOffertInSfx(hpatch_StreamPos_t* out_diffDataOffert,hpatch_StreamPos_t* out_diffDataSize);
-#endif
-
-#if (_IS_NEED_MAIN)
-#   if (_IS_USED_WIN32_UTF8_WAPI)
-int wmain(int argc,wchar_t* argv_w[]){
-    char* argv_utf8[hpatch_kPathMaxSize*3/sizeof(char*)];
-    if (!_wFileNames_to_utf8((const wchar_t**)argv_w,argc,argv_utf8,sizeof(argv_utf8)))
-        return HPATCH_OPTIONS_ERROR;
-    SetDefaultStringLocale();
-    return hpatch_cmd_line(argc,argv_utf8);
-}
-#   else
-int main(int argc, const char * argv[]){
-    return hpatch_cmd_line(argc,argv);
-}
-#   endif
-#endif
-
-#if (_IS_NEED_DIR_DIFF_PATCH)
-static hpatch_BOOL _toChecksumSet(const char* psets,TDirPatchChecksumSet* checksumSet){
-    while (hpatch_TRUE) {
-        const char* pend=findUntilEnd(psets,'-');
-        size_t len=(size_t)(pend-psets);
-        if (len==0) return hpatch_FALSE; //error no set
-        if        ((len==4)&&(0==memcmp(psets,"diff",len))){
-            checksumSet->isCheck_dirDiffData=hpatch_TRUE;
-        }else  if ((len==3)&&(0==memcmp(psets,"old",len))){
-            checksumSet->isCheck_oldRefData=hpatch_TRUE;
-        }else  if ((len==3)&&(0==memcmp(psets,"new",len))){
-            checksumSet->isCheck_newRefData=hpatch_TRUE;
-        }else  if ((len==4)&&(0==memcmp(psets,"copy",len))){
-            checksumSet->isCheck_copyFileData=hpatch_TRUE;
-        }else  if ((len==3)&&(0==memcmp(psets,"all",len))){
-            checksumSet->isCheck_dirDiffData=hpatch_TRUE;
-            checksumSet->isCheck_oldRefData=hpatch_TRUE;
-            checksumSet->isCheck_newRefData=hpatch_TRUE;
-            checksumSet->isCheck_copyFileData=hpatch_TRUE;
-        }else  if ((len==2)&&(0==memcmp(psets,"no",len))){
-            checksumSet->isCheck_dirDiffData=hpatch_FALSE;
-            checksumSet->isCheck_oldRefData=hpatch_FALSE;
-            checksumSet->isCheck_newRefData=hpatch_FALSE;
-            checksumSet->isCheck_copyFileData=hpatch_FALSE;
-        }else{
-            return hpatch_FALSE;//error unknow set
-        }
-        if (*pend=='\0')
-            return hpatch_TRUE; //ok
-        else
-            psets=pend+1;
-    }
-}
-#endif
-
-#define _return_check(value,exitCode,errorInfo){ \
-    if (!(value)) { fprintf(stderr,errorInfo " ERROR!\n"); return exitCode; } }
-
-#define _options_check(value,errorInfo){ \
-    if (!(value)) { fprintf(stderr,"options " errorInfo " ERROR!\n\n"); \
-        printUsage(); return HPATCH_OPTIONS_ERROR; } }
-
-#define kPatchCacheSize_min      (hpatch_kStreamCacheSize*8)
-#define kPatchCacheSize_bestmin  ((size_t)1<<21)
-#define kPatchCacheSize_default  ((size_t)1<<26)
-#define kPatchCacheSize_bestmax  ((size_t)1<<30)
-
-#define _kNULL_VALUE    (-1)
-#define _kNULL_SIZE     (~(size_t)0)
-
-int hpatch_cmd_line(int argc, const char * argv[]){
-    hpatch_BOOL isLoadOldAll=_kNULL_VALUE;
-    hpatch_BOOL isForceOverwrite=_kNULL_VALUE;
-    hpatch_BOOL isOutputHelp=_kNULL_VALUE;
-    hpatch_BOOL isOutputVersion=_kNULL_VALUE;
-    hpatch_BOOL isOldPathInputEmpty=_kNULL_VALUE;
-#if (_IS_NEED_SFX)
-    hpatch_BOOL isRunSFX=_kNULL_VALUE;
-    const char* out_SFX=0;
-    const char* selfExecuteFile=0;
-#endif
-    size_t      patchCacheSize=0;
-#if (_IS_NEED_DIR_DIFF_PATCH)
-    size_t      kMaxOpenFileNumber=_kNULL_SIZE; //only used in stream dir patch
-    TDirPatchChecksumSet checksumSet={0,hpatch_FALSE,hpatch_TRUE,hpatch_TRUE,hpatch_FALSE}; //DEFAULT
-#endif
-    #define kMax_arg_values_size 3
-    const char* arg_values[kMax_arg_values_size]={0};
-    int         arg_values_size=0;
-    int         i;
-    for (i=1; i<argc; ++i) {
-        const char* op=argv[i];
-        _options_check(op!=0,"?");
-        if (op[0]!='-'){
-            hpatch_BOOL isEmpty=(strlen(op)==0);
-            _options_check(arg_values_size<kMax_arg_values_size,"input count");
-            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[arg_values_size]=op; //path: file or directory
-            ++arg_values_size;
-            continue;
-        }
-        _options_check((op!=0)&&(op[0]=='-'),"?");
-        switch (op[1]) {
-            case 'm':{
-                _options_check((isLoadOldAll==_kNULL_VALUE)&&(op[2]=='\0'),"-m");
-                isLoadOldAll=hpatch_TRUE;
-            } break;
-            case 's':{
-                _options_check((isLoadOldAll==_kNULL_VALUE)&&((op[2]=='-')||(op[2]=='\0')),"-s");
-                isLoadOldAll=hpatch_FALSE; //stream
-                if (op[2]=='-'){
-                    const char* pnum=op+3;
-                    _options_check(kmg_to_size(pnum,strlen(pnum),&patchCacheSize),"-s-?");
-                }else{
-                    patchCacheSize=kPatchCacheSize_default;
-                }
-            } break;
-#if (_IS_NEED_SFX)
-            case 'X':{
-                if (op[2]=='#'){
-                    const char* pnum=op+3;
-                    _options_check(out_SFX==0,"-X#?");
-                    out_SFX=pnum;
-                    _options_check(strlen(out_SFX)>0,"-X#?");
-                }else if (op[2]=='-'){
-                    _options_check(selfExecuteFile==0,"-X-?");
-                    if ((op[3]=='e')&&(op[4]=='x')&&(op[5]=='e')&&(op[6]=='#')){
-                        selfExecuteFile=op+7;
-                        _options_check(strlen(selfExecuteFile)>0,"-X-exe#?");
-                    }else{
-                        _options_check(hpatch_FALSE,"-X-?");
-                    }
-                }else{
-                    _options_check((isRunSFX==_kNULL_VALUE)&&(op[2]=='\0'),"-X");
-                    isRunSFX=hpatch_TRUE;
-                }
-            } break;
-#endif
-            case 'f':{
-                _options_check((isForceOverwrite==_kNULL_VALUE)&&(op[2]=='\0'),"-f");
-                isForceOverwrite=hpatch_TRUE;
-            } break;
-#if (_IS_NEED_DIR_DIFF_PATCH)
-            case 'C':{
-                const char* psets=op+3;
-                _options_check((op[2]=='-'),"-C-?");
-                memset(&checksumSet,0,sizeof(checksumSet));//all set false
-                _options_check(_toChecksumSet(psets,&checksumSet),"-C-?");
-            } break;
-            case 'n':{
-                const char* pnum=op+3;
-                _options_check((kMaxOpenFileNumber==_kNULL_SIZE)&&(op[2]=='-'),"-n-?");
-                _options_check(kmg_to_size(pnum,strlen(pnum),&kMaxOpenFileNumber),"-n-?");
-            } break;
-#endif
-            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;
-            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 (_IS_NEED_SFX)
-    if (isRunSFX==_kNULL_VALUE)
-        isRunSFX=hpatch_FALSE;
-    if (arg_values_size==0){
-        hpatch_StreamPos_t _diffDataOffert=0;
-        hpatch_StreamPos_t _diffDataSize=0;
-        if (getDiffDataOffertInSfx(&_diffDataOffert,&_diffDataSize)){//autoExtractSFX
-            isForceOverwrite=hpatch_TRUE;
-            isRunSFX=hpatch_TRUE;
-        }
-    }
-#endif
-    if (isOutputHelp||isOutputVersion){
-        if (isOutputHelp)
-            printUsage();//with version
-        else
-            printVersion();
-#if (_IS_NEED_SFX)
-        if ((arg_values_size==0)&&(!isRunSFX)&&(out_SFX==0)&&(selfExecuteFile==0))
-#else
-        if (arg_values_size==0)
-#endif
-            return 0; //ok
-    }
-#if (_IS_NEED_DIR_DIFF_PATCH)
-    if (kMaxOpenFileNumber==_kNULL_SIZE)
-        kMaxOpenFileNumber=kMaxOpenFileNumber_default_patch;
-    if (kMaxOpenFileNumber<kMaxOpenFileNumber_default_min)
-        kMaxOpenFileNumber=kMaxOpenFileNumber_default_min;
-#endif
-    
-    if (isLoadOldAll==_kNULL_VALUE){
-        isLoadOldAll=hpatch_FALSE;
-        patchCacheSize=kPatchCacheSize_default;
-    }
-    if (isOldPathInputEmpty==_kNULL_VALUE)
-        isOldPathInputEmpty=hpatch_FALSE;
-    
-#if (_IS_NEED_SFX)
-    if ((out_SFX!=0)||(selfExecuteFile!=0)){ //create SFX
-        _options_check(out_SFX!=0,"-X#?");
-        _options_check(!isRunSFX, "-X");
-        _options_check(arg_values_size==1,"-X# input count");
-        {
-            const char* diffFileName =arg_values[0];
-            if (selfExecuteFile==0) selfExecuteFile=argv[0];
-            if (!isForceOverwrite){
-                hpatch_TPathType   outPathType;
-                _return_check(hpatch_getPathStat(out_SFX,&outPathType,0),
-                              HPATCH_PATHTYPE_ERROR,"get outSelfExtractArchive type");
-                _return_check(outPathType==kPathType_notExist,
-                              HPATCH_PATHTYPE_ERROR,"outSelfExtractArchive already exists, overwrite");
-            }
-            return createSfx(selfExecuteFile,diffFileName,out_SFX);
-        }
-    }else if (isRunSFX){//patch run as SFX mode
-        _options_check((arg_values_size==2)||(arg_values_size==0),"-X input count");
-    }else
-#endif
-    {//patch default mode
-        _options_check(arg_values_size==3,"input count");
-    }
-    {//patch
-        const char* oldPath     =0;
-        const char* diffFileName=0;
-        const char* outNewPath  =0;
-#if (_IS_NEED_SFX)
-#   ifdef _WIN32
-        const char* kSFX_curDefaultPath=".\\";
-#   else
-        const char* kSFX_curDefaultPath="./";
-#   endif
-        const char* kSFX_emptyPath="";
-#endif
-#if (_IS_NEED_DIR_DIFF_PATCH)
-        TDirDiffInfo dirDiffInfo;
-        hpatch_BOOL  isOutDir;
-#endif
-        hpatch_BOOL  isSamePath;
-        hpatch_StreamPos_t diffDataOffert=0;
-        hpatch_StreamPos_t diffDataSize=0;
-#if (_IS_NEED_SFX)
-        if (isRunSFX){
-            printf("run as SFX mode!\n");
-            _return_check(getDiffDataOffertInSfx(&diffDataOffert,&diffDataSize),
-                          HPATCH_RUN_SFX_NOTSFX_ERROR,"not found diff data in selfExecuteFile");
-            diffFileName=argv[0];//selfExecuteFileName
-            if (arg_values_size==0){//autoExtractSFX
-                oldPath     =kSFX_emptyPath;
-                outNewPath  =kSFX_curDefaultPath;
-            }else{
-                oldPath     =arg_values[0];
-                outNewPath  =arg_values[1];
-            }
-            //continue
-        }else
-#endif
-        {
-            oldPath     =arg_values[0];
-            diffFileName=arg_values[1];
-            outNewPath  =arg_values[2];
-        }
-        
-        isSamePath=hpatch_getIsSamePath(oldPath,outNewPath);
-        _return_check(!hpatch_getIsSamePath(oldPath,diffFileName),
-                      HPATCH_PATHTYPE_ERROR,"oldPath diffFile same path");
-        _return_check(!hpatch_getIsSamePath(outNewPath,diffFileName),
-                      HPATCH_PATHTYPE_ERROR,"outNewPath diffFile same path");
-        if (!isForceOverwrite){
-            hpatch_TPathType   outNewPathType;
-            _return_check(hpatch_getPathStat(outNewPath,&outNewPathType,0),
-                          HPATCH_PATHTYPE_ERROR,"get outNewPath type");
-            _return_check(outNewPathType==kPathType_notExist,
-                          HPATCH_PATHTYPE_ERROR,"outNewPath already exists, overwrite");
-        }
-        if (isSamePath)
-            _return_check(isForceOverwrite,HPATCH_PATHTYPE_ERROR,"oldPath outNewPath same path, overwrite");
-#if (_IS_NEED_DIR_DIFF_PATCH)
-        _return_check(getDirDiffInfoByFile(diffFileName,&dirDiffInfo,diffDataOffert,diffDataSize),
-                      HPATCH_OPENREAD_ERROR,"input diffFile open read");
-        isOutDir=(dirDiffInfo.isDirDiff)&&(dirDiffInfo.newPathIsDir);
-#endif
-        if (!isSamePath){ // out new file or new dir
-#if (_IS_NEED_DIR_DIFF_PATCH)
-            if (dirDiffInfo.isDirDiff){
-                return hpatch_dir(oldPath,diffFileName,outNewPath,isLoadOldAll,patchCacheSize,kMaxOpenFileNumber,
-                                  &checksumSet,&defaultPatchDirlistener,diffDataOffert,diffDataSize);
-            }else
-#endif
-            {
-                return hpatch(oldPath,diffFileName,outNewPath,
-                              isLoadOldAll,patchCacheSize,diffDataOffert,diffDataSize);
-            }
-        }else
-#if (_IS_NEED_DIR_DIFF_PATCH)
-            if (!isOutDir)
-#endif
-        { // isSamePath==true and out to file
-            int result;
-            char newTempName[hpatch_kPathMaxSize];
-#if (_IS_NEED_DIR_DIFF_PATCH)
-            if (dirDiffInfo.isDirDiff)
-                _return_check(!dirDiffInfo.oldPathIsDir,
-                              HPATCH_PATHTYPE_ERROR,"can not use file overwrite oldDirectory");
-#endif
-            // 1. patch to newTempName
-            // 2. if patch ok    then  { delelte oldPath; rename newTempName to oldPath; }
-            //    if patch error then  { delelte newTempName; }
-            _return_check(hpatch_getTempPathName(outNewPath,newTempName,newTempName+hpatch_kPathMaxSize),
-                          HPATCH_TEMPPATH_ERROR,"getTempPathName(outNewPath)");
-            printf("NOTE: outNewPath temp file will be rename to oldPath name after patch!\n");
-#if (_IS_NEED_DIR_DIFF_PATCH)
-            if (dirDiffInfo.isDirDiff){
-                result=hpatch_dir(oldPath,diffFileName,newTempName,isLoadOldAll,patchCacheSize,
-                                  kMaxOpenFileNumber,&checksumSet,&defaultPatchDirlistener,diffDataOffert,diffDataSize);
-            }else
-#endif
-            {
-                result=hpatch(oldPath,diffFileName,newTempName,
-                              isLoadOldAll,patchCacheSize,diffDataOffert,diffDataSize);
-            }
-            if (result==HPATCH_SUCCESS){
-                _return_check(hpatch_removeFile(oldPath),
-                              HPATCH_DELETEPATH_ERROR,"removeFile(oldPath)");
-                _return_check(hpatch_renamePath(newTempName,oldPath),
-                              HPATCH_RENAMEPATH_ERROR,"renamePath(temp,oldPath)");
-                printf("outNewPath temp file renamed to oldPath name!\n");
-            }else{//patch error
-                if (!hpatch_removeFile(newTempName)){
-                    printf("WARNING: can't remove temp file \"");
-                    hpatch_printPath_utf8(newTempName); printf("\"\n");
-                }
-            }
-            return result;
-        }
-#if (_IS_NEED_DIR_DIFF_PATCH)
-        else{ // isDirDiff==true isSamePath==true and out to dir
-            int result;
-            char newTempDir[hpatch_kPathMaxSize];
-            assert(dirDiffInfo.isDirDiff);
-            _return_check(dirDiffInfo.oldPathIsDir,
-                          HPATCH_PATHTYPE_ERROR,"can not use directory overwrite oldFile");
-            _return_check(hpatch_getTempPathName(outNewPath,newTempDir,newTempDir+hpatch_kPathMaxSize),
-                          HPATCH_TEMPPATH_ERROR,"getTempPathName(outNewPath)");
-            printf("NOTE: all in outNewPath temp directory will be move to oldDirectory after patch!\n");
-            result=hpatch_dir(oldPath,diffFileName,newTempDir,isLoadOldAll,patchCacheSize,
-                              kMaxOpenFileNumber,&checksumSet,&tempDirPatchListener,diffDataOffert,diffDataSize);
-            if (result==HPATCH_SUCCESS){
-                printf("all in outNewPath temp directory moved to oldDirectory!\n");
-            }else if(!hpatch_isPathNotExist(newTempDir)){
-                printf("WARNING: not remove temp directory \"");
-                hpatch_printPath_utf8(newTempDir); printf("\"\n");
-            }
-            return result;
-        }
-#endif
-    }
-}
-
-
-#define  check_on_error(errorType) { \
-    if (result==HPATCH_SUCCESS) result=errorType; if (!_isInClear){ goto clear; } }
-#define  check(value,errorType,errorInfo) { \
-    if (!(value)){ fprintf(stderr,errorInfo " ERROR!\n"); check_on_error(errorType); } }
-
-
-static hpatch_BOOL getDecompressPlugin(const hpatch_compressedDiffInfo* diffInfo,
-                                       hpatch_TDecompress** out_decompressPlugin){
-    hpatch_TDecompress*  decompressPlugin=0;
-    assert(0==*out_decompressPlugin);
-    if (strlen(diffInfo->compressType)>0){
-#ifdef  _CompressPlugin_zlib
-        if ((!decompressPlugin)&&zlibDecompressPlugin.is_can_open(diffInfo->compressType))
-            decompressPlugin=&zlibDecompressPlugin;
-#endif
-#ifdef  _CompressPlugin_bz2
-        if ((!decompressPlugin)&&bz2DecompressPlugin.is_can_open(diffInfo->compressType))
-            decompressPlugin=&bz2DecompressPlugin;
-#endif
-#ifdef  _CompressPlugin_lzma
-        if ((!decompressPlugin)&&lzmaDecompressPlugin.is_can_open(diffInfo->compressType))
-            decompressPlugin=&lzmaDecompressPlugin;
-#endif
-#ifdef  _CompressPlugin_lzma2
-        if ((!decompressPlugin)&&lzma2DecompressPlugin.is_can_open(diffInfo->compressType))
-            decompressPlugin=&lzma2DecompressPlugin;
-#endif
-#if (defined(_CompressPlugin_lz4) || (defined(_CompressPlugin_lz4hc)))
-        if ((!decompressPlugin)&&lz4DecompressPlugin.is_can_open(diffInfo->compressType))
-            decompressPlugin=&lz4DecompressPlugin;
-#endif
-#ifdef  _CompressPlugin_zstd
-        if ((!decompressPlugin)&&zstdDecompressPlugin.is_can_open(diffInfo->compressType))
-            decompressPlugin=&zstdDecompressPlugin;
-#endif
-#ifdef  _CompressPlugin_brotli
-        if ((!decompressPlugin)&&brotliDecompressPlugin.is_can_open(diffInfo->compressType))
-            decompressPlugin=&brotliDecompressPlugin;
-#endif
-#ifdef  _CompressPlugin_lzham
-        if ((!decompressPlugin)&&lzhamDecompressPlugin.is_can_open(diffInfo->compressType))
-            decompressPlugin=&lzhamDecompressPlugin;
-#endif
-    }
-    if (!decompressPlugin){
-        if (diffInfo->compressedCount>0){
-            return hpatch_FALSE; //error
-        }else{
-            if (strlen(diffInfo->compressType)>0)
-                printf("  diffFile added useless compress tag \"%s\"\n",diffInfo->compressType);
-            decompressPlugin=0;
-        }
-    }else{
-        printf("hpatchz run with decompress plugin: \"%s\" (need decompress %d)\n",
-               diffInfo->compressType,diffInfo->compressedCount);
-    }
-    *out_decompressPlugin=decompressPlugin;
-    return hpatch_TRUE;
-}
-
-#if (_IS_NEED_DIR_DIFF_PATCH)
-static void _trySetChecksum(hpatch_TChecksum** out_checksumPlugin,const char* checksumType,
-                            hpatch_TChecksum* testChecksumPlugin){
-    if ((*out_checksumPlugin)!=0) return;
-    if (0==strcmp(checksumType,testChecksumPlugin->checksumType()))
-        *out_checksumPlugin=testChecksumPlugin;
-}
-static hpatch_BOOL findChecksum(hpatch_TChecksum** out_checksumPlugin,const char* checksumType){
-    *out_checksumPlugin=0;
-    if (strlen(checksumType)==0) return hpatch_TRUE;
-#ifdef _ChecksumPlugin_crc32
-    _trySetChecksum(out_checksumPlugin,checksumType,&crc32ChecksumPlugin);
-#endif
-#ifdef _ChecksumPlugin_adler32
-    _trySetChecksum(out_checksumPlugin,checksumType,&adler32ChecksumPlugin);
-#endif
-#ifdef _ChecksumPlugin_adler64
-    _trySetChecksum(out_checksumPlugin,checksumType,&adler64ChecksumPlugin);
-#endif
-#ifdef _ChecksumPlugin_fadler32
-    _trySetChecksum(out_checksumPlugin,checksumType,&fadler32ChecksumPlugin);
-#endif
-#ifdef _ChecksumPlugin_fadler64
-    _trySetChecksum(out_checksumPlugin,checksumType,&fadler64ChecksumPlugin);
-#endif
-#ifdef _ChecksumPlugin_fadler128
-    _trySetChecksum(out_checksumPlugin,checksumType,&fadler128ChecksumPlugin);
-#endif
-#ifdef _ChecksumPlugin_md5
-    _trySetChecksum(out_checksumPlugin,checksumType,&md5ChecksumPlugin);
-#endif
-    return (0!=*out_checksumPlugin);
-}
-#endif
-
-#define _free_mem(p) { if (p) { free(p); p=0; } }
-
-static TByte* getPatchMemCache(hpatch_BOOL isLoadOldAll,size_t patchCacheSize,
-                               hpatch_StreamPos_t oldDataSize,size_t* out_memCacheSize){
-    TByte* temp_cache=0;
-    size_t temp_cache_size;
-    if (isLoadOldAll){
-        size_t addSize=kPatchCacheSize_bestmin;
-        if (addSize>oldDataSize+kPatchCacheSize_min)
-            addSize=(size_t)(oldDataSize+kPatchCacheSize_min);
-        assert(patchCacheSize==0);
-        temp_cache_size=(size_t)(oldDataSize+addSize);
-        if (temp_cache_size!=oldDataSize+addSize)
-            temp_cache_size=kPatchCacheSize_bestmax;//can not load all,load part
-    }else{
-        if (patchCacheSize<kPatchCacheSize_min)
-            patchCacheSize=kPatchCacheSize_min;
-        temp_cache_size=patchCacheSize;
-        if (temp_cache_size>oldDataSize+kPatchCacheSize_bestmin)
-            temp_cache_size=(size_t)(oldDataSize+kPatchCacheSize_bestmin);
-    }
-    while (!temp_cache) {
-        temp_cache=(TByte*)malloc(temp_cache_size);
-        if ((!temp_cache)&&(temp_cache_size>=kPatchCacheSize_min*2))
-            temp_cache_size>>=1;
-    }
-    *out_memCacheSize=(temp_cache)?temp_cache_size:0;
-    return temp_cache;
-}
-
-
-int hpatch(const char* oldFileName,const char* diffFileName,
-           const char* outNewFileName,hpatch_BOOL isLoadOldAll,size_t patchCacheSize,
-           hpatch_StreamPos_t diffDataOffert,hpatch_StreamPos_t diffDataSize){
-    int     result=HPATCH_SUCCESS;
-    int     _isInClear=hpatch_FALSE;
-    double  time0=clock_s();
-#if (_IS_NEED_SINGLE_STREAM_DIFF)
-    hpatch_BOOL isSingleStreamDiff=hpatch_FALSE;
-    hpatch_singleCompressedDiffInfo sdiffInfo;
-#endif
-    hpatch_TDecompress*  decompressPlugin=0;
-    hpatch_TFileStreamOutput    newData;
-    hpatch_TFileStreamInput     diffData;
-    hpatch_TFileStreamInput     oldData;
-    hpatch_TStreamInput* poldData=&oldData.base;
-    TByte*               temp_cache=0;
-    size_t               temp_cache_size;
-    hpatch_StreamPos_t   savedNewSize=0;
-    hpatch_BOOL          patch_result;
-    hpatch_TFileStreamInput_init(&oldData);
-    hpatch_TFileStreamInput_init(&diffData);
-    hpatch_TFileStreamOutput_init(&newData);
-    {//open
-        printf(    "old : \""); hpatch_printPath_utf8(oldFileName);
-        printf("\"\ndiff: \""); hpatch_printPath_utf8(diffFileName);
-        printf("\"\nout : \""); hpatch_printPath_utf8(outNewFileName);
-        printf("\"\n");
-        if (0==strcmp(oldFileName,"")){ // isOldPathInputEmpty
-            mem_as_hStreamInput(&oldData.base,0,0);
-        }else{
-            check(hpatch_TFileStreamInput_open(&oldData,oldFileName),
-                  HPATCH_OPENREAD_ERROR,"open oldFile for read");
-        }
-        check(hpatch_TFileStreamInput_open(&diffData,diffFileName),
-              HPATCH_OPENREAD_ERROR,"open diffFile for read");
-#if (_IS_NEED_SFX)
-        if (diffDataOffert>0){ //run sfx
-            check(hpatch_TFileStreamInput_setOffset(&diffData,diffDataOffert),
-                  HPATCH_RUN_SFX_DIFFOFFSERT_ERROR,"readed sfx diffFile offset");
-            check(diffData.base.streamSize>=diffDataSize,
-                  HPATCH_RUN_SFX_DIFFOFFSERT_ERROR,"readed sfx diffFile size");
-            diffData.base.streamSize=diffDataSize;
-        }
-#endif
-    }
-
-    {
-        hpatch_compressedDiffInfo diffInfo;
-        if (!getCompressedDiffInfo(&diffInfo,&diffData.base)){
-            check(!diffData.fileError,HPATCH_FILEREAD_ERROR,"read diffFile");
-#if (_IS_NEED_SINGLE_STREAM_DIFF)
-            if (getSingleCompressedDiffInfo(&sdiffInfo,&diffData.base,0)){
-                memcpy(diffInfo.compressType,sdiffInfo.compressType,strlen(sdiffInfo.compressType)+1);
-                diffInfo.compressedCount=(sdiffInfo.compressType[0]!='\0')?1:0;
-                diffInfo.newDataSize=sdiffInfo.newDataSize;
-                diffInfo.oldDataSize=sdiffInfo.oldDataSize;
-                patchCacheSize+=(size_t)sdiffInfo.stepMemSize;
-                if (patchCacheSize<sdiffInfo.stepMemSize+hpatch_kStreamCacheSize*3)
-                    patchCacheSize=sdiffInfo.stepMemSize+hpatch_kStreamCacheSize*3;
-                isSingleStreamDiff=hpatch_TRUE;
-                printf("patch single compressed stream diffData!\n");
-            }else
-#endif
-                check(hpatch_FALSE,HPATCH_HDIFFINFO_ERROR,"is hdiff file? getCompressedDiffInfo()");
-        }
-        if (poldData->streamSize!=diffInfo.oldDataSize){
-            fprintf(stderr,"oldFile dataSize %" PRIu64 " != diffFile saved oldDataSize %" PRIu64 " ERROR!\n",
-                    poldData->streamSize,diffInfo.oldDataSize);
-            check_on_error(HPATCH_FILEDATA_ERROR);
-        }
-        if(!getDecompressPlugin(&diffInfo,&decompressPlugin)){
-            fprintf(stderr,"can not decompress \"%s\" data ERROR!\n",diffInfo.compressType);
-            check_on_error(HPATCH_COMPRESSTYPE_ERROR);
-        }
-        savedNewSize=diffInfo.newDataSize;
-    }
-    check(hpatch_TFileStreamOutput_open(&newData, outNewFileName,savedNewSize),
-          HPATCH_OPENWRITE_ERROR,"open out newFile for write");
-    printf("oldDataSize : %" PRIu64 "\ndiffDataSize: %" PRIu64 "\nnewDataSize : %" PRIu64 "\n",
-           poldData->streamSize,diffData.base.streamSize,newData.base.streamSize);
-    
-    temp_cache=getPatchMemCache(isLoadOldAll,patchCacheSize,poldData->streamSize, &temp_cache_size);
-    check(temp_cache,HPATCH_MEM_ERROR,"alloc cache memory");
-#if (_IS_NEED_SINGLE_STREAM_DIFF)
-    if (isSingleStreamDiff){
-        check(temp_cache_size>=sdiffInfo.stepMemSize+hpatch_kStreamCacheSize*3,HPATCH_MEM_ERROR,"alloc cache memory");
-        patch_result=patch_single_compressed_diff(&newData.base,poldData,&diffData.base,sdiffInfo.diffDataPos,
-                                                  sdiffInfo.uncompressedSize,decompressPlugin,sdiffInfo.coverCount,
-                                                  sdiffInfo.stepMemSize,temp_cache,temp_cache+temp_cache_size);
-    }else
-#endif
-        patch_result=patch_decompress_with_cache(&newData.base,poldData,&diffData.base,decompressPlugin,
-                                                 temp_cache,temp_cache+temp_cache_size);
-    if (!patch_result){
-        check(!oldData.fileError,HPATCH_FILEREAD_ERROR,"oldFile read");
-        check(!diffData.fileError,HPATCH_FILEREAD_ERROR,"diffFile read");
-        check(!newData.fileError,HPATCH_FILEWRITE_ERROR,"out newFile write");
-        check(hpatch_FALSE,HPATCH_PATCH_ERROR,"patch run");
-    }
-    if (newData.out_length!=newData.base.streamSize){
-        fprintf(stderr,"out newFile dataSize %" PRIu64 " != diffFile saved newDataSize %" PRIu64 " ERROR!\n",
-               newData.out_length,newData.base.streamSize);
-        check_on_error(HPATCH_FILEDATA_ERROR);
-    }
-    printf("  patch ok!\n");
-    
-clear:
-    _isInClear=hpatch_TRUE;
-    check(hpatch_TFileStreamOutput_close(&newData),HPATCH_FILECLOSE_ERROR,"out newFile close");
-    check(hpatch_TFileStreamInput_close(&diffData),HPATCH_FILECLOSE_ERROR,"diffFile close");
-    check(hpatch_TFileStreamInput_close(&oldData),HPATCH_FILECLOSE_ERROR,"oldFile close");
-    _free_mem(temp_cache);
-    printf("\nhpatchz time: %.3f s\n",(clock_s()-time0));
-    return result;
-}
-
-#if (_IS_NEED_DIR_DIFF_PATCH)
-int hpatch_dir(const char* oldPath,const char* diffFileName,const char* outNewPath,
-               hpatch_BOOL isLoadOldAll,size_t patchCacheSize,size_t kMaxOpenFileNumber,
-               TDirPatchChecksumSet* checksumSet,IHPatchDirListener* hlistener,
-               hpatch_StreamPos_t diffDataOffert,hpatch_StreamPos_t diffDataSize){
-    int     result=HPATCH_SUCCESS;
-    int     _isInClear=hpatch_FALSE;
-    double  time0=clock_s();
-    hpatch_TFileStreamInput     diffData;
-    TDirPatcher          dirPatcher;
-    const TDirDiffInfo*  dirDiffInfo=0;
-    TByte*               p_temp_mem=0;
-    TByte*               temp_cache=0;
-    size_t               temp_cache_size;
-    const hpatch_TStreamInput*  oldStream=0;
-    const hpatch_TStreamOutput* newStream=0;
-    hpatch_TFileStreamInput_init(&diffData);
-    TDirPatcher_init(&dirPatcher);
-    assert(0!=strcmp(oldPath,outNewPath));
-    {//dir diff info
-        hpatch_BOOL  rt;
-        hpatch_TPathType    oldType;
-        if (0==strcmp(oldPath,"")){ // isOldPathInputEmpty
-            oldType=kPathType_file; //as empty file
-        }else{
-            check(hpatch_getPathStat(oldPath,&oldType,0),HPATCH_PATHTYPE_ERROR,"get oldPath type");
-            check((oldType!=kPathType_notExist),HPATCH_PATHTYPE_ERROR,"oldPath not exist");
-        }
-        check(hpatch_TFileStreamInput_open(&diffData,diffFileName),HPATCH_OPENREAD_ERROR,"open diffFile for read");
-#if (_IS_NEED_SFX)
-        if (diffDataOffert>0){ //run sfx
-            check(hpatch_TFileStreamInput_setOffset(&diffData,diffDataOffert),
-                  HPATCH_RUN_SFX_DIFFOFFSERT_ERROR,"readed sfx diffFile offset");
-            check(diffData.base.streamSize>=diffDataSize,
-                  HPATCH_RUN_SFX_DIFFOFFSERT_ERROR,"readed sfx diffFile size");
-            diffData.base.streamSize=diffDataSize;
-        }
-#endif
-        rt=TDirPatcher_open(&dirPatcher,&diffData.base,&dirDiffInfo);
-        if((!rt)||(!dirDiffInfo->isDirDiff)){
-            check(!diffData.fileError,HPATCH_FILEREAD_ERROR,"read diffFile");
-            check(hpatch_FALSE,DIRPATCH_DIRDIFFINFO_ERROR,"is hdiff file? get dir diff info");
-        }
-        if (dirDiffInfo->oldPathIsDir){
-            check(kPathType_dir==oldType,HPATCH_PATHTYPE_ERROR,"input old path need dir");
-        }else{
-            check(kPathType_file==oldType,HPATCH_PATHTYPE_ERROR,"input old path need file");
-        }
-        printf(        dirDiffInfo->oldPathIsDir?"old  dir: \"":"old file: \"");
-        hpatch_printPath_utf8(oldPath);
-        if (dirDiffInfo->oldPathIsDir&&(!hpatch_getIsDirName(oldPath))) printf("%c",kPatch_dirSeparator);
-        printf(                                             "\"\ndiffFile: \"");
-        hpatch_printPath_utf8(diffFileName);
-        printf(dirDiffInfo->newPathIsDir?"\"\nout  dir: \"":"\"\nout file: \"");
-        hpatch_printPath_utf8(outNewPath);
-        if (dirDiffInfo->newPathIsDir&&(!hpatch_getIsDirName(outNewPath))) printf("%c",kPatch_dirSeparator);
-        printf("\"\n");
-    }
-    {//decompressPlugin
-        hpatch_TDecompress*  decompressPlugin=0;
-        hpatch_compressedDiffInfo hdiffInfo;
-        hdiffInfo=dirDiffInfo->hdiffInfo;
-        hdiffInfo.compressedCount+=(dirDiffInfo->dirDataIsCompressed)?1:0;
-        if(!getDecompressPlugin(&hdiffInfo,&decompressPlugin)){
-            fprintf(stderr,"can not decompress \"%s\" data ERROR!\n",hdiffInfo.compressType);
-            check_on_error(HPATCH_COMPRESSTYPE_ERROR);
-        }
-        //load dir data
-        check(TDirPatcher_loadDirData(&dirPatcher,decompressPlugin,oldPath,outNewPath),
-              DIRPATCH_LAOD_DIRDIFFDATA_ERROR,"load dir data in diffFile");
-    }
-    check(hlistener->patchBegin(hlistener,&dirPatcher),
-          DIRPATCH_PATCHBEGIN_ERROR,"dir patch begin");
-    {// checksumPlugin
-        int wantChecksumCount = checksumSet->isCheck_dirDiffData+checksumSet->isCheck_oldRefData+
-        checksumSet->isCheck_newRefData+checksumSet->isCheck_copyFileData;
-        assert(checksumSet->checksumPlugin==0);
-        if (wantChecksumCount>0){
-            if (strlen(dirDiffInfo->checksumType)==0){
-                memset(checksumSet,0,sizeof(*checksumSet));
-                printf("  NOTE: no checksum saved in diffFile,can not do checksum\n");
-            }else{
-                if (!findChecksum(&checksumSet->checksumPlugin,dirDiffInfo->checksumType)){
-                    fprintf(stderr,"not found checksumType \"%s\" ERROR!\n",dirDiffInfo->checksumType);
-                    check_on_error(DIRPATCH_CHECKSUMTYPE_ERROR);
-                }
-                printf("hpatchz run with checksum plugin: \"%s\" (need checksum %d)\n",
-                       dirDiffInfo->checksumType,wantChecksumCount);
-                if (!TDirPatcher_checksum(&dirPatcher,checksumSet)){
-                    check(!TDirPatcher_isDiffDataChecksumError(&dirPatcher),
-                          DIRPATCH_CHECKSUM_DIFFDATA_ERROR,"diffFile checksum");
-                    check(hpatch_FALSE,DIRPATCH_CHECKSUMSET_ERROR,"diffFile set checksum");
-                }
-            }
-        }
-    }
-    {//info
-        const _TDirDiffHead* head=&dirPatcher.dirDiffHead;
-        printf("DirPatch new path count: %" PRIu64 " (fileCount:%" PRIu64 ")\n",(hpatch_StreamPos_t)head->newPathCount,
-               (hpatch_StreamPos_t)(head->sameFilePairCount+head->newRefFileCount));
-        printf("    copy from old count: %" PRIu64 " (dataSize: %" PRIu64 ")\n",
-               (hpatch_StreamPos_t)head->sameFilePairCount,head->sameFileSize);
-        printf("     ref old file count: %" PRIu64 "\n",(hpatch_StreamPos_t)head->oldRefFileCount);
-        printf("     ref new file count: %" PRIu64 "\n",(hpatch_StreamPos_t)head->newRefFileCount);
-        printf("oldRefSize  : %" PRIu64 "\ndiffDataSize: %" PRIu64 "\nnewRefSize  : %" PRIu64 " (all newSize: %" PRIu64 ")\n",
-               dirDiffInfo->hdiffInfo.oldDataSize,diffData.base.streamSize,dirDiffInfo->hdiffInfo.newDataSize,
-               dirDiffInfo->hdiffInfo.newDataSize+head->sameFileSize);
-    }
-    {//mem cache
-        p_temp_mem=getPatchMemCache(isLoadOldAll,patchCacheSize,dirDiffInfo->hdiffInfo.oldDataSize, &temp_cache_size);
-        check(p_temp_mem,HPATCH_MEM_ERROR,"alloc cache memory");
-        temp_cache=p_temp_mem;
-    }
-    {//old data
-        if (temp_cache_size>=dirDiffInfo->hdiffInfo.oldDataSize+kPatchCacheSize_min){
-            // all old while auto cache by patch; not need open old files at same time
-            kMaxOpenFileNumber=kMaxOpenFileNumber_limit_min;
-        }
-        check(TDirPatcher_openOldRefAsStream(&dirPatcher,kMaxOpenFileNumber,&oldStream),
-              DIRPATCH_OPEN_OLDPATH_ERROR,"open oldFile");
-    }
-    {//new data
-        check(TDirPatcher_openNewDirAsStream(&dirPatcher,&hlistener->base,&newStream),
-              DIRPATCH_OPEN_NEWPATH_ERROR,"open newFile");
-    }
-    //patch
-    if(!TDirPatcher_patch(&dirPatcher,newStream,oldStream,temp_cache,temp_cache+temp_cache_size)){
-        check(!TDirPatcher_isOldRefDataChecksumError(&dirPatcher),
-              DIRPATCH_CHECKSUM_OLDDATA_ERROR,"oldFile checksum");
-        check(!TDirPatcher_isCopyDataChecksumError(&dirPatcher),
-              DIRPATCH_CHECKSUM_COPYDATA_ERROR,"copyOldFile checksum");
-        check(!TDirPatcher_isNewRefDataChecksumError(&dirPatcher),
-              DIRPATCH_CHECKSUM_NEWDATA_ERROR,"newFile checksum");
-        check(hpatch_FALSE,DIRPATCH_PATCH_ERROR,"dir patch run");
-    }
-clear:
-    _isInClear=hpatch_TRUE;
-    check(hlistener->patchFinish(hlistener,result==HPATCH_SUCCESS),
-          DIRPATCH_PATCHFINISH_ERROR,"dir patch finish");
-    check(TDirPatcher_closeNewDirStream(&dirPatcher),DIRPATCH_CLOSE_NEWPATH_ERROR,"newPath close");
-    check(TDirPatcher_closeOldRefStream(&dirPatcher),DIRPATCH_CLOSE_OLDPATH_ERROR,"oldPath close");
-    TDirPatcher_close(&dirPatcher);
-    check(hpatch_TFileStreamInput_close(&diffData),HPATCH_FILECLOSE_ERROR,"diffFile close");
-    _free_mem(p_temp_mem);
-    printf("\nhpatchz dir patch time: %.3f s\n",(clock_s()-time0));
-    return result;
-}
-#endif
-
-#if (_IS_NEED_SFX)
-#define _sfx_guid_size      16
-#define _sfx_guid_node_size (_sfx_guid_size+sizeof(hpatch_uint32_t)+sizeof(hpatch_uint64_t))
-//_sfx_guid_node:{fd6c3a9d-1498-4a5d-a9d5-7303a82fd08e-ffffffff-ffffffffffffffff}
-TByte _sfx_guid_node[_sfx_guid_node_size]={
-    0xfd,0x6c,0x3a,0x9d,
-    0x14,0x98,
-    0x4a,0x5d,
-    0xa9,0xd5,
-    0x73,0x03,0xa8,0x2f,0xd0,0x8e,
-    0xff,0xff,0xff,0xff,  // saved diffDataOffert , selfExecute fileSize < 4GB
-    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff}; // diffDataSize
-
-static TByte* _search(TByte* src,TByte* src_end,const TByte* sub,const TByte* sub_end){
-    size_t sub_len=(size_t)(sub_end-sub);
-    TByte* search_last=src_end-sub_len;
-    TByte  c0;
-    if (sub_len==0) return src;
-    if ((size_t)(src_end-src)<sub_len)  return src_end;
-    c0=*sub;
-    for (;src<=search_last;++src) {
-        if (c0!=*src){
-            continue;
-        }else{
-            hpatch_BOOL is_eq=hpatch_TRUE;
-            size_t i;
-            for (i=1; i<sub_len;++i) {
-                if (sub[i]!=src[i]){
-                    is_eq=hpatch_FALSE;
-                    break;
-                }
-            }
-            if (!is_eq)
-                continue;
-            else
-                return src;
-        }
-    }
-    return src_end;
-}
-
-static int createSfx_notCheckDiffFile_byStream(const hpatch_TStreamInput*  selfExecute,
-                                               const hpatch_TStreamInput*  diffData,
-                                               const hpatch_TStreamOutput* out_sfxData){
-    int     result=HPATCH_SUCCESS;
-    int     _isInClear=hpatch_FALSE;
-    TByte*  buf=0;
-    TByte*  pmem=0;
-    hpatch_StreamPos_t  writePos=0;
-    hpatch_BOOL         isFoundGuid=hpatch_FALSE;
-    const hpatch_StreamPos_t  diffDataOffert=selfExecute->streamSize;
-    const hpatch_StreamPos_t  diffDataSize=diffData->streamSize;
-    {//mem
-        pmem=(TByte*)malloc(_sfx_guid_node_size+hpatch_kFileIOBufBetterSize);
-        check(pmem!=0,HPATCH_MEM_ERROR,"createSfx() malloc");
-        memset(pmem,0,_sfx_guid_node_size);
-        buf=pmem+_sfx_guid_node_size; // [ _sfx_guid_node_size | hpatch_kFileIOBufBetterSize ]
-    }
-    {//copy exe ,find guid pos and write diffDataOffset
-        const hpatch_uint32_t dataSize=(hpatch_uint32_t)(selfExecute->streamSize);
-        hpatch_StreamPos_t readPos=0;
-        check(dataSize==selfExecute->streamSize,
-              HPATCH_CREATE_SFX_SFXTYPE_ERROR,"createSfx() selfExecute fileSize");
-        while (readPos < dataSize) {
-            TByte* wbuf=0;
-            const TByte* wbuf_end=0;
-            TByte* rbuf_end=0;
-            size_t readLen=hpatch_kFileIOBufBetterSize;
-            if (readLen+readPos > dataSize)
-                readLen=(size_t)(dataSize - readPos);
-            rbuf_end=buf+readLen;
-            check(selfExecute->read(selfExecute,readPos,buf,rbuf_end),
-                  HPATCH_FILEREAD_ERROR,"createSfx() read selfExecute");
-            wbuf=(readPos!=0)?pmem:buf;
-            if (!isFoundGuid){ //find in [wbuf..rbuf_end)
-                TByte*  pos=_search(wbuf,rbuf_end,_sfx_guid_node,_sfx_guid_node+_sfx_guid_node_size);
-                if (pos!=rbuf_end){
-                    size_t i;
-                    isFoundGuid=hpatch_TRUE;
-                    for (i=0; i<sizeof(hpatch_uint32_t); ++i){
-                        size_t di=_sfx_guid_size+i;
-                        assert(pos[di]==0xff);
-                        pos[di]=(TByte)(diffDataOffert>>(8*i));
-                    }
-                    for (i=0; i<sizeof(hpatch_uint64_t); ++i){
-                        size_t di=_sfx_guid_size+sizeof(hpatch_uint32_t)+i;
-                        assert(pos[di]==0xff);
-                        pos[di]=(TByte)(diffDataSize>>(8*i));
-                    }
-                }
-            }
-            wbuf_end=(readPos+readLen<dataSize)?(rbuf_end-_sfx_guid_node_size):rbuf_end;
-            check(out_sfxData->write(out_sfxData,writePos,wbuf,wbuf_end),
-                  HPATCH_FILEWRITE_ERROR,"createSfx() write sfxData");
-            memcpy(pmem,rbuf_end-_sfx_guid_node_size,_sfx_guid_node_size);
-            readPos+=readLen;
-            writePos+=(size_t)(wbuf_end-wbuf);
-        }
-    }
-    assert(writePos==diffDataOffert);
-    check(isFoundGuid,HPATCH_CREATE_SFX_SFXTYPE_ERROR,"createSfx() selfExecute type");
-    {//copy diffData
-        const hpatch_StreamPos_t dataSize=diffData->streamSize;
-        hpatch_StreamPos_t readPos=0;
-        while (readPos < dataSize) {
-            size_t readLen=hpatch_kFileIOBufBetterSize;
-            if (readLen+readPos > dataSize)
-                readLen=(size_t)(dataSize - readPos);
-            check(diffData->read(diffData,readPos,buf,buf+readLen),
-                  HPATCH_FILEREAD_ERROR,"createSfx() read diffData");
-            check(out_sfxData->write(out_sfxData,writePos,buf,buf+readLen),
-                  HPATCH_FILEWRITE_ERROR,"createSfx() write sfxData");
-            readPos+=readLen;
-            writePos+=readLen;
-        }
-    }
-clear:
-    _isInClear=hpatch_TRUE;
-    _free_mem(pmem);
-    return result;
-}
-
-int createSfx_notCheckDiffFile(const char* selfExecuteFileName,const char* diffFileName,
-                               const char* out_sfxFileName){
-    int     result=HPATCH_SUCCESS;
-    int     _isInClear=hpatch_FALSE;
-    hpatch_TFileStreamInput  exeData;
-    hpatch_TFileStreamInput  diffData;
-    hpatch_TFileStreamOutput out_sfxData;
-    hpatch_TFileStreamInput_init(&exeData);
-    hpatch_TFileStreamInput_init(&diffData);
-    hpatch_TFileStreamOutput_init(&out_sfxData);
-    printf(    "selfExecute: \""); hpatch_printPath_utf8(selfExecuteFileName);
-    printf("\"\ndiffFile   : \""); hpatch_printPath_utf8(diffFileName);
-    printf("\"\nout sfxFile: \""); hpatch_printPath_utf8(out_sfxFileName);
-    printf("\"\n\n");
-    {//open
-        hpatch_StreamPos_t sfxFileLength=0;
-        check(hpatch_TFileStreamInput_open(&exeData,selfExecuteFileName),
-              HPATCH_OPENREAD_ERROR,"createSfx() open selfExecuteFile read");
-        sfxFileLength+=exeData.base.streamSize;
-        check(hpatch_TFileStreamInput_open(&diffData,diffFileName),
-              HPATCH_OPENREAD_ERROR,"createSfx() open diffFileName read");
-        sfxFileLength+=diffData.base.streamSize;
-        check(hpatch_TFileStreamOutput_open(&out_sfxData,out_sfxFileName,sfxFileLength),
-              HPATCH_OPENWRITE_ERROR,"createSfx() open sfxFile write");
-    }
-    result=createSfx_notCheckDiffFile_byStream(&exeData.base,&diffData.base,&out_sfxData.base);
-    if (result!=HPATCH_SUCCESS) check_on_error(result);
-    assert(out_sfxData.base.streamSize==out_sfxData.out_length);
-    check(hpatch_TFileStreamOutput_close(&out_sfxData),HPATCH_FILECLOSE_ERROR,"createSfx() out sfxFile close");
-    printf("sfxFileSize: %" PRIu64 "\n",out_sfxData.base.streamSize);
-    if (hpatch_getIsExecuteFile(selfExecuteFileName)){
-        check(hpatch_setIsExecuteFile(out_sfxFileName),
-              HPATCH_CREATE_SFX_EXECUTETAG_ERROR,"createSfx() set sfxFile Execute tag");
-    }
-    printf("out sfxFile ok!\n");
-clear:
-    _isInClear=hpatch_TRUE;
-    check(hpatch_TFileStreamOutput_close(&out_sfxData),HPATCH_FILECLOSE_ERROR,"createSfx() out sfxFile close");
-    check(hpatch_TFileStreamInput_close(&diffData),HPATCH_FILECLOSE_ERROR,"createSfx() diffFile close");
-    check(hpatch_TFileStreamInput_close(&exeData),HPATCH_FILECLOSE_ERROR,"createSfx() selfExecuteFile close");
-    return result;
-}
-
-static hpatch_BOOL _getIsCompressedDiffFile(const char* diffFileName){
-    hpatch_TFileStreamInput diffData;
-    hpatch_compressedDiffInfo diffInfo;
-    hpatch_BOOL result=hpatch_TRUE;
-    hpatch_TFileStreamInput_init(&diffData);
-    if (!hpatch_TFileStreamInput_open(&diffData,diffFileName)) return hpatch_FALSE;
-    result=getCompressedDiffInfo(&diffInfo,&diffData.base);
-    if (!hpatch_TFileStreamInput_close(&diffData)) return hpatch_FALSE;
-    return result;
-}
-
-int createSfx(const char* selfExecuteFileName,const char* diffFileName,const char* out_sfxFileName){
-    int     result=HPATCH_SUCCESS;
-    int     _isInClear=hpatch_FALSE;
-    {//check diffFile type
-        hpatch_BOOL isDiffFile=hpatch_FALSE;
-#if (_IS_NEED_DIR_DIFF_PATCH)
-        if (!isDiffFile)
-            isDiffFile=getIsDirDiffFile(diffFileName);
-#endif
-        if (!isDiffFile)
-            isDiffFile=_getIsCompressedDiffFile(diffFileName);
-        check(isDiffFile,HPATCH_CREATE_SFX_DIFFFILETYPE_ERROR,
-              "createSfx() input diffFile is unsupported type");
-    }
-    result=createSfx_notCheckDiffFile(selfExecuteFileName,diffFileName,out_sfxFileName);
-clear:
-    _isInClear=hpatch_TRUE;
-    return result;
-}
-
-hpatch_BOOL getDiffDataOffertInSfx(hpatch_StreamPos_t* out_diffDataOffert,hpatch_StreamPos_t* out_diffDataSize){
-    hpatch_uint32_t diffOff=0;
-    hpatch_uint64_t diffSize=0;
-    size_t i;
-    for (i=0; i<sizeof(hpatch_uint32_t); ++i){
-        size_t si=_sfx_guid_size+i;
-        diffOff|=((hpatch_uint32_t)_sfx_guid_node[si])<<(8*i);
-    }
-    if (diffOff==(~(hpatch_uint32_t)0)) return hpatch_FALSE;
-    assert(diffOff>_sfx_guid_node_size);
-    
-    for (i=0; i<sizeof(hpatch_uint64_t); ++i){
-        size_t si=_sfx_guid_size+sizeof(hpatch_uint32_t)+i;
-        diffSize|=((hpatch_uint64_t)_sfx_guid_node[si])<<(8*i);
-    }
-    if (diffSize==(~(hpatch_uint64_t)0)) return hpatch_FALSE;
-    
-    *out_diffDataOffert=diffOff;
-    *out_diffDataSize=diffSize;
-    return hpatch_TRUE;
-}
-
-#endif // _IS_NEED_SFX