react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/dir_patch.c

@@ -38,36 +38,33 @@ static const char* kVersionType="HDIFF19";
 
 #define TUInt hpatch_StreamPos_t
 
-#define  checki(value,errorInfo) { if (!(value)){ LOG_ERR("dir_patch " errorInfo " error!\n");  \
+#define  check(value) { if (!(value)){ fprintf(stderr,"check "#value" error!\n");  \
                                        result=hpatch_FALSE; goto clear; } }
-#define  check(value) checki(value,"check " #value)
 
 #define unpackUIntTo(puint,sclip) \
-    checki(_TStreamCacheClip_unpackUIntWithTag(sclip,puint,0),"unpackUIntTo() saved data")
+    check(_TStreamCacheClip_unpackUIntWithTag(sclip,puint,0))
 
-#define unpackToSize(psize,sclip) {  \
-    TUInt v; unpackUIntTo(&v,sclip); \
+#define unpackToSize(psize,sclip) { \
+    TUInt v; check(_TStreamCacheClip_unpackUIntWithTag(sclip,&v,0)); \
     if (sizeof(TUInt)!=sizeof(size_t)) check(v==(size_t)v); \
     *(psize)=(size_t)v; }
 
 
-hpatch_BOOL getDirDiffInfoByFile(TDirDiffInfo* out_info,const char* diffFileName,
+hpatch_BOOL getDirDiffInfoByFile(const char* diffFileName,TDirDiffInfo* out_info,
                                  hpatch_StreamPos_t diffDataOffert,hpatch_StreamPos_t diffDataSize){
     hpatch_BOOL          result=hpatch_TRUE;
     hpatch_TFileStreamInput     diffData;
     hpatch_TFileStreamInput_init(&diffData);
     
-    checki(hpatch_TFileStreamInput_open(&diffData,diffFileName),"getDirDiffInfoByFile() file open");
+    check(hpatch_TFileStreamInput_open(&diffData,diffFileName));
     if (diffDataOffert>0){
-        checki(hpatch_TFileStreamInput_setOffset(&diffData,diffDataOffert),
-            "getDirDiffInfoByFile() file setOffset");
+        check(hpatch_TFileStreamInput_setOffset(&diffData,diffDataOffert));
         check(diffData.base.streamSize>=diffDataSize);
         diffData.base.streamSize=diffDataSize;
     }
-    result=getDirDiffInfo(out_info,&diffData.base);
+    result=getDirDiffInfo(&diffData.base,out_info);
+    check(hpatch_TFileStreamInput_close(&diffData));
 clear:
-    if (!hpatch_TFileStreamInput_close(&diffData)) 
-        { LOG_ERR("dir_patch getDirDiffInfoByFile() file close error!\n"); result=hpatch_FALSE; }
     return result;
 }
 
@@ -124,7 +121,7 @@ static hpatch_BOOL _read_dirdiff_head(TDirDiffInfo* out_info,_TDirDiffHead* out_
         unpackToSize(&out_info->checksumByteSize,headClip);
         out_info->checksumOffset=_TStreamCacheClip_readPosOfSrcStream(headClip);
         if (out_isAppendContinue){
-            if (_TStreamCacheClip_leaveSize(headClip) <= out_info->checksumByteSize*4){
+            if (_TStreamCacheClip_streamSize(headClip) <= out_info->checksumByteSize*4){
                 *out_isAppendContinue=hpatch_TRUE;
                 return hpatch_TRUE; //need more diffData, not error
             }else{
@@ -152,18 +149,6 @@ static hpatch_BOOL _read_dirdiff_head(TDirDiffInfo* out_info,_TDirDiffHead* out_
         if (isLoadHDiffInfo){
             TStreamInputClip_init(&hdiffStream,dirDiffFile,out_head->hdiffDataOffset,
                                   out_head->hdiffDataOffset+out_head->hdiffDataSize);
-#if (_IS_NEED_SINGLE_STREAM_DIFF)
-            out_info->isSingleCompressedDiff=hpatch_FALSE;
-            out_info->sdiffInfo.stepMemSize=0;
-            if (getSingleCompressedDiffInfo(&out_info->sdiffInfo,&hdiffStream.base,0)){
-                out_info->isSingleCompressedDiff=hpatch_TRUE;
-                if (strlen(out_info->sdiffInfo.compressType)==0)
-                    memcpy(out_info->sdiffInfo.compressType,savedCompressType,savedCompressTypeLen+1); //with '\0'
-                else
-                    check(0==strcmp(savedCompressType,out_info->sdiffInfo.compressType));
-                _singleDiffInfoToHDiffInfo(&out_info->hdiffInfo,&out_info->sdiffInfo);
-            }else
-#endif
             check(getCompressedDiffInfo(&out_info->hdiffInfo,&hdiffStream.base));
             check(savedOldRefSize==out_info->hdiffInfo.oldDataSize);
             check(savedNewRefSize==out_info->hdiffInfo.newDataSize);
@@ -186,7 +171,7 @@ hpatch_BOOL read_dirdiff_head(TDirDiffInfo* out_info,_TDirDiffHead* out_head,
     return _read_dirdiff_head(out_info,out_head,dirDiffFile,0);
 }
 
-hpatch_BOOL getDirDiffInfo(TDirDiffInfo* out_info,const hpatch_TStreamInput* diffFile){
+hpatch_BOOL getDirDiffInfo(const hpatch_TStreamInput* diffFile,TDirDiffInfo* out_info){
     _TDirDiffHead head;
     return read_dirdiff_head(out_info,&head,diffFile);
 }
@@ -242,35 +227,38 @@ clear:
 #define _pchecksumTemp(_self)       ((_self)->_pChecksumMem+(_self)->dirDiffInfo.checksumByteSize*4)
 
 static hpatch_BOOL _checksum_append(hpatch_TChecksum* checksumPlugin,hpatch_checksumHandle csHandle,
-                                    const hpatch_TStreamInput* data,hpatch_StreamPos_t begin,hpatch_StreamPos_t end,
-                                    hpatch_byte* tempBuf,hpatch_byte* tempBufEnd){
+                                    const hpatch_TStreamInput* data,
+                                    hpatch_StreamPos_t begin,hpatch_StreamPos_t end){
     hpatch_BOOL result=hpatch_TRUE;
+#define __bufCacheSize (hpatch_kStreamCacheSize*4)
+    TByte buf[__bufCacheSize];
     while (begin<end) {
-        size_t len=tempBufEnd-tempBuf;
+        size_t len=__bufCacheSize;
         if (len>(hpatch_StreamPos_t)(end-begin))
             len=(size_t)(end-begin);
-        check(data->read(data,begin,tempBuf,tempBuf+len));
-        checksumPlugin->append(csHandle,tempBuf,tempBuf+len);
+        check(data->read(data,begin,buf,buf+len));
+        checksumPlugin->append(csHandle,buf,buf+len);
         begin+=len;
     }
     return hpatch_TRUE;
 clear:
     return result;
+#undef __bufCacheSize
 }
 
 static hpatch_BOOL _do_checksum(TDirPatcher* self,const TByte* checksumTest,TByte* checksumTemp,
-                                const hpatch_TStreamInput* data,hpatch_StreamPos_t skipBegin,hpatch_StreamPos_t skipEnd,
-			                	hpatch_byte* tempBuf,hpatch_byte* tempBufEnd){
+                                const hpatch_TStreamInput* data,
+                                hpatch_StreamPos_t skipBegin,hpatch_StreamPos_t skipEnd){
     hpatch_BOOL result=hpatch_TRUE;
     size_t checksumByteSize=self->dirDiffInfo.checksumByteSize;
     hpatch_TChecksum*   checksumPlugin=self->_checksumSet.checksumPlugin;
     hpatch_checksumHandle  csHandle=checksumPlugin->open(checksumPlugin);
     checksumPlugin->begin(csHandle);
     if (0<skipBegin){
-        check(_checksum_append(checksumPlugin,csHandle,data,0,skipBegin,tempBuf,tempBufEnd));
+        check(_checksum_append(checksumPlugin,csHandle,data,0,skipBegin));
     }
     if (skipEnd<data->streamSize){
-        check(_checksum_append(checksumPlugin,csHandle,data,skipEnd,data->streamSize,tempBuf,tempBufEnd));
+        check(_checksum_append(checksumPlugin,csHandle,data,skipEnd,data->streamSize));
     }
     checksumPlugin->end(csHandle,checksumTemp,checksumTemp+checksumByteSize);
     check(0==memcmp(checksumTest,checksumTemp,checksumByteSize));
@@ -279,8 +267,7 @@ clear:
     return result;
 }
 
-hpatch_BOOL TDirPatcher_checksum(TDirPatcher* self,const TDirPatchChecksumSet* checksumSet,
-			                	 hpatch_byte* tempBuf,hpatch_byte* tempBufEnd){
+hpatch_BOOL TDirPatcher_checksum(TDirPatcher* self,const TDirPatchChecksumSet* checksumSet){
     hpatch_BOOL result=hpatch_TRUE;
     hpatch_BOOL isHaveCheck=checksumSet->isCheck_oldRefData||checksumSet->isCheck_newRefData||
                             checksumSet->isCheck_copyFileData||checksumSet->isCheck_dirDiffData;
@@ -297,15 +284,14 @@ hpatch_BOOL TDirPatcher_checksum(TDirPatcher* self,const TDirPatchChecksumSet* c
         self->_checksumSet=*checksumSet;
         self->_pChecksumMem=(TByte*)malloc(checksumByteSize*(4+1)); //+1 for checksumTemp
         check(self->_pChecksumMem!=0);
-        checki(self->_dirDiffData->read(self->_dirDiffData,checksumOffset,
-                                       self->_pChecksumMem,self->_pChecksumMem+checksumByteSize*4),
-                                       "self->_dirDiffData->read");
+        check(self->_dirDiffData->read(self->_dirDiffData,checksumOffset,
+                                       self->_pChecksumMem,self->_pChecksumMem+checksumByteSize*4));
         
         //checksum dirDiffData
         if (self->_checksumSet.isCheck_dirDiffData){
             hpatch_StreamPos_t savedDiffChecksumOffset=checksumOffset+checksumByteSize*3;
             if(!_do_checksum(self,_pchecksumDiffData(self),_pchecksumTemp(self),self->_dirDiffData,
-                             savedDiffChecksumOffset,savedDiffChecksumOffset+checksumByteSize,tempBuf,tempBufEnd))
+                             savedDiffChecksumOffset,savedDiffChecksumOffset+checksumByteSize))
                 self->_isDiffDataChecksumError=hpatch_TRUE;
             check(!self->_isDiffDataChecksumError);
         }
@@ -320,9 +306,6 @@ hpatch_BOOL TDirPatcher_loadDirData(TDirPatcher* self,hpatch_TDecompress* decomp
     hpatch_BOOL result=hpatch_TRUE;
     size_t               memSize=0;
     TByte*               curMem=0;
-    char*                pathEnd;
-    const size_t         oldPathLen=strlen(oldPath_utf8);
-    const size_t         newPathLen=strlen(newPath_utf8);
     const _TDirDiffHead* head=&self->dirDiffHead;
     const size_t         pathSumSize=head->oldPathSumSize+head->newPathSumSize;
     TStreamCacheClip        headStream;
@@ -336,17 +319,16 @@ hpatch_BOOL TDirPatcher_loadDirData(TDirPatcher* self,hpatch_TDecompress* decomp
     //dir head data clip stream
     {
         hpatch_StreamPos_t curPos=self->dirDiffHead.headDataOffset;
-        checki(getStreamClip(&headStream,&decompresser,self->dirDiffHead.headDataSize,
-                             self->dirDiffHead.headDataCompressedSize,self->_dirDiffData,&curPos,
-                             decompressPlugin,temp_cache,hpatch_kStreamCacheSize),
-               "TDirPatcher_loadDirData() getStreamClip");
+        check(getStreamClip(&headStream,&decompresser,self->dirDiffHead.headDataSize,
+                            self->dirDiffHead.headDataCompressedSize,self->_dirDiffData,&curPos,
+                            decompressPlugin,temp_cache,hpatch_kStreamCacheSize));
     }
     //mem
     memSize = (head->oldPathCount+head->newPathCount)*sizeof(const char*)
             + (head->oldRefFileCount+head->newRefFileCount+head->newExecuteCount)*sizeof(size_t)
             + head->sameFilePairCount*sizeof(hpatch_TSameFilePair)
             + (head->newRefFileCount)*sizeof(hpatch_StreamPos_t)
-            + (oldPathLen+newPathLen+4) + pathSumSize;
+            + hpatch_kPathMaxSize*2 + pathSumSize;
     self->_pDiffDataMem=malloc(memSize);
     check(self->_pDiffDataMem!=0);
     curMem=self->_pDiffDataMem;
@@ -360,25 +342,26 @@ hpatch_BOOL TDirPatcher_loadDirData(TDirPatcher* self,hpatch_TDecompress* decomp
     self->_newDir.dataSamePairList=(const hpatch_TSameFilePair*)curMem;
         curMem+=head->sameFilePairCount*sizeof(hpatch_TSameFilePair);
     
-    self->_oldRootDir=(char*)curMem; curMem+=oldPathLen+2;
-    pathEnd=setDirPath((char*)self->_oldRootDir,(char*)self->_oldRootDir+oldPathLen+2,oldPath_utf8);
-    check(pathEnd!=0);
-    if (!self->dirDiffInfo.oldPathIsDir) *(--pathEnd)=0; //without '/'
-    self->_oldRootDir_len=pathEnd-self->_oldRootDir;
-    self->_newDir._newRootDir=(char*)curMem; curMem+=newPathLen+2;
-    pathEnd=setDirPath((char*)self->_newDir._newRootDir,(char*)self->_newDir._newRootDir+newPathLen+2,newPath_utf8);
-    check(pathEnd!=0);
-    if (!self->dirDiffInfo.newPathIsDir) *(--pathEnd)=0; //without '/'
-    self->_newDir._newRootDir_len=pathEnd-self->_newDir._newRootDir;
+    self->_oldRootDir=(char*)curMem;
+    self->_oldRootDir_bufEnd=self->_oldRootDir+hpatch_kPathMaxSize;  curMem+=hpatch_kPathMaxSize;
+    self->_oldRootDir_end=setDirPath(self->_oldRootDir,self->_oldRootDir_bufEnd,oldPath_utf8);
+    check(0!=self->_oldRootDir_end);
+    if (!self->dirDiffInfo.oldPathIsDir)
+        --self->_oldRootDir_end; //without '/'
+    self->_newDir._newRootDir=(char*)curMem;
+    self->_newDir._newRootDir_bufEnd=self->_newDir._newRootDir+hpatch_kPathMaxSize;  curMem+=hpatch_kPathMaxSize;
+    self->_newDir._newRootDir_end=setDirPath(self->_newDir._newRootDir,self->_newDir._newRootDir_bufEnd,newPath_utf8);
+    check(0!=self->_newDir._newRootDir_end);
+    if (!self->dirDiffInfo.newPathIsDir)
+        --self->_newDir._newRootDir_end;//without '/'
     //read old & new path List
     check(_TStreamCacheClip_readDataTo(&headStream,curMem,curMem+pathSumSize));
     formatDirTagForLoad((char*)curMem,(char*)curMem+pathSumSize);
     curMem+=pathSumSize;
     
     assert(curMem-memSize==self->_pDiffDataMem);
-    checki(clipCStrsTo((const char*)curMem-pathSumSize,(const char*)curMem,
-                       (const char**)self->oldUtf8PathList,head->oldPathCount+head->newPathCount),
-           "TDirPatcher_loadDirData() clipCStrsTo");
+    check(clipCStrsTo((const char*)curMem-pathSumSize,(const char*)curMem,
+                      (const char**)self->oldUtf8PathList,head->oldPathCount+head->newPathCount));
     //read oldRefList
     check(readIncListTo(&headStream,(size_t*)self->oldRefList,head->oldRefFileCount,head->oldPathCount));
     //read newRefList
@@ -386,12 +369,11 @@ hpatch_BOOL TDirPatcher_loadDirData(TDirPatcher* self,hpatch_TDecompress* decomp
     //read newRefSizeList
     check(readListTo(&headStream,(hpatch_StreamPos_t*)self->_newDir.newRefSizeList,head->newRefFileCount));
     //read dataSamePairList
-    checki(readSamePairListTo(&headStream,(hpatch_TSameFilePair*)self->_newDir.dataSamePairList,head->sameFilePairCount,
-                              head->newPathCount,head->oldPathCount),
-           "TDirPatcher_loadDirData() readSamePairListTo");
+    check(readSamePairListTo(&headStream,(hpatch_TSameFilePair*)self->_newDir.dataSamePairList,head->sameFilePairCount,
+                             head->newPathCount,head->oldPathCount));
     //read newExecuteList
     check(readIncListTo(&headStream,(size_t*)self->_newDir.newExecuteList,head->newExecuteCount,head->newPathCount));
-    check(_TStreamCacheClip_leaveSize(&headStream)==self->dirDiffHead.privateReservedDataSize);
+    check(_TStreamCacheClip_streamSize(&headStream)==self->dirDiffHead.privateReservedDataSize);
 clear:
     if (decompresser.decompressHandle){
         if (!decompressPlugin->close(decompressPlugin,decompresser.decompressHandle))
@@ -410,13 +392,11 @@ hpatch_BOOL  _openRes(hpatch_IResHandle* res,hpatch_TStreamInput** out_stream){
     const char*         utf8fileName=0;
     assert(resIndex<self->dirDiffHead.oldRefFileCount);
     assert(file->m_file==0);
-    char _tmpPath[hpatch_kPathMaxSize];
-    utf8fileName=TDirPatcher_getOldRefPathByRefIndex(self,resIndex,_tmpPath,_tmpPath+sizeof(_tmpPath));
+    utf8fileName=TDirPatcher_getOldRefPathByRefIndex(self,resIndex);
     check(utf8fileName!=0);
     check(hpatch_TFileStreamInput_open(file,utf8fileName));
     *out_stream=&file->base;
 clear:
-    if (!result) set_ferr(self->fileError,file->fileError);
     return result;
 }
 hpatch_BOOL _closeRes(hpatch_IResHandle* res,const hpatch_TStreamInput* stream){
@@ -429,7 +409,6 @@ hpatch_BOOL _closeRes(hpatch_IResHandle* res,const hpatch_TStreamInput* stream){
     assert(stream==&file->base);
     check(hpatch_TFileStreamInput_close(file));
 clear:
-    mix_ferr(self->fileError,file->fileError);
     return result;
 }
 
@@ -460,8 +439,7 @@ hpatch_BOOL TDirPatcher_openOldRefAsStream(TDirPatcher* self,size_t kMaxOpenFile
         for (i=0; i<refCount;++i){
             hpatch_TPathType          oldPathType;
             hpatch_StreamPos_t fileSize;
-            char _tmpPath[hpatch_kPathMaxSize];
-            const char* oldRefFileName=TDirPatcher_getOldRefPathByRefIndex(self,i,_tmpPath,_tmpPath+sizeof(_tmpPath));
+            const char* oldRefFileName=TDirPatcher_getOldRefPathByRefIndex(self,i);
             check(oldRefFileName!=0);
             check(hpatch_getPathStat(oldRefFileName,&oldPathType,&fileSize));
             check(oldPathType==kPathType_file);
@@ -474,9 +452,8 @@ hpatch_BOOL TDirPatcher_openOldRefAsStream(TDirPatcher* self,size_t kMaxOpenFile
         check(sumFSize==self->dirDiffInfo.hdiffInfo.oldDataSize);
         //open
         check(hpatch_TResHandleLimit_open(&self->_resLimit,kMaxOpenFileNumber,self->_resList,refCount));
-        checki(hpatch_TRefStream_open(&self->_oldRefStream,self->_resLimit.streamList,
-                                      self->_resLimit.streamCount,1),
-               "TDirPatcher_openOldRefAsStream() hpatch_TRefStream_open");
+        check(hpatch_TRefStream_open(&self->_oldRefStream,self->_resLimit.streamList,
+                                     self->_resLimit.streamCount,1));
         *out_oldRefStream=self->_oldRefStream.stream;
     }
 clear:
@@ -498,7 +475,8 @@ hpatch_BOOL TDirPatcher_closeOldRefStream(TDirPatcher* self){
     self->_oldFileList=0;
     
     self->_oldRootDir=0;
-    self->_oldRootDir_len=0;
+    self->_oldRootDir_end=0;
+    self->_oldRootDir_bufEnd=0;
     if (self->_pOldRefMem){
         free(self->_pOldRefMem);
         self->_pOldRefMem=0;
@@ -507,10 +485,9 @@ hpatch_BOOL TDirPatcher_closeOldRefStream(TDirPatcher* self){
 }
 
 
-static const char* _getOldPathByIndex(const struct hpatch_IOldPathListener* listener,size_t oldPathIndex,
-                                      char* out_pathBuf,char* out_pathBufEnd){
+static const char* _getOldPathByIndex(struct hpatch_IOldPathListener* listener,size_t oldPathIndex){
     TDirPatcher* self=(TDirPatcher*)listener->listenerImport;
-    return TDirPatcher_getOldPathByIndex(self,oldPathIndex,out_pathBuf,out_pathBufEnd);
+    return TDirPatcher_getOldPathByIndex(self,oldPathIndex);
 }
 
 hpatch_BOOL TDirPatcher_openNewDirAsStream(TDirPatcher* self,IDirPatchListener* listener,
@@ -540,58 +517,40 @@ hpatch_BOOL TDirPatcher_closeNewDirStream(TDirPatcher* self){
 }
 
 static hpatch_inline
-void _do_checksumOldRef(TDirPatcher* self,const hpatch_TStreamInput* oldData,hpatch_byte* tempBuf,hpatch_byte* tempBufEnd){
-    if(!_do_checksum(self,_pchecksumOldRef(self),_pchecksumTemp(self),oldData,0,0,tempBuf,tempBufEnd)){
+void _do_checksumOldRef(TDirPatcher* self,const hpatch_TStreamInput* oldData){
+    if(!_do_checksum(self,_pchecksumOldRef(self),_pchecksumTemp(self),oldData,0,0)){
         self->_isOldRefDataChecksumError=hpatch_TRUE;
     }
 }
 
 hpatch_BOOL TDirPatcher_patch(TDirPatcher* self,const hpatch_TStreamOutput* out_newData,
                               const hpatch_TStreamInput* oldData,
-                              TByte* temp_cache,TByte* temp_cache_end,size_t threadNum){
-    size_t patchCacheSize_min = hpatch_kStreamCacheSize*8;
+                              TByte* temp_cache,TByte* temp_cache_end){
+#define kPatchCacheSize_min      (hpatch_kStreamCacheSize*8)
     hpatch_BOOL         result=hpatch_TRUE;
     TStreamInputClip    hdiffData;
     hpatch_TStreamInput _cacheOldData;
-#if (_IS_NEED_SINGLE_STREAM_DIFF)
-    if (self->dirDiffInfo.isSingleCompressedDiff)
-        patchCacheSize_min+=(size_t)self->dirDiffInfo.sdiffInfo.stepMemSize;
-#endif
     if (self->_checksumSet.isCheck_oldRefData){
-        if ((size_t)(temp_cache_end-temp_cache)>=oldData->streamSize+patchCacheSize_min){
+        if ((size_t)(temp_cache_end-temp_cache)>=oldData->streamSize+kPatchCacheSize_min){
             //load all oldData into memory for optimize speed of checksum oldData
-            size_t readLen=(size_t)oldData->streamSize;
-            check(oldData->read(oldData,0,temp_cache,temp_cache+readLen));
-            mem_as_hStreamInput(&_cacheOldData,temp_cache,temp_cache+readLen);
-            temp_cache+=readLen;
+            size_t redLen=(size_t)oldData->streamSize;
+            check(oldData->read(oldData,0,temp_cache,temp_cache+redLen));
+            mem_as_hStreamInput(&_cacheOldData,temp_cache,temp_cache+redLen);
+            temp_cache+=redLen;
             oldData=&_cacheOldData;
         }
         {//checksum oldRefData
-            _do_checksumOldRef(self,oldData,temp_cache,temp_cache_end);
+            _do_checksumOldRef(self,oldData);
             check(!self->_isOldRefDataChecksumError);
         }
     }
     TStreamInputClip_init(&hdiffData,self->_dirDiffData,self->dirDiffHead.hdiffDataOffset,
                           self->dirDiffHead.hdiffDataOffset+self->dirDiffHead.hdiffDataSize);
-#if (_IS_NEED_SINGLE_STREAM_DIFF)
-    if (self->dirDiffInfo.isSingleCompressedDiff){
-        hpatch_singleCompressedDiffInfo* sdiffInfo=&self->dirDiffInfo.sdiffInfo;
-        check(((size_t)(temp_cache_end-temp_cache))>=sdiffInfo->stepMemSize+hpatch_kStreamCacheSize*3);
-        checki(patch_single_compressed_diff(out_newData,oldData,&hdiffData.base,sdiffInfo->diffDataPos,
-                                            sdiffInfo->uncompressedSize,sdiffInfo->compressedSize,self->_decompressPlugin,
-                                            sdiffInfo->coverCount,(size_t)sdiffInfo->stepMemSize,
-                                            temp_cache,temp_cache_end,0,threadNum),
-               "TDirPatcher_patch() patch_single_compressed_diff");
-    }else
-#endif
-    checki(patch_decompress_with_cache(out_newData,oldData,&hdiffData.base,
-                                       self->_decompressPlugin,temp_cache,temp_cache_end),
-           "TDirPatcher_patch() patch_decompress_with_cache");
-clear: 
-    if (!_TDirPatcher_closeNewFileHandles(self)) 
-        { LOG_ERR("check _TDirPatcher_closeNewFileHandles(self) error!\n"); result=hpatch_FALSE; }
-    if (!_TDirPatcher_closeOldFileHandles(self))
-        { LOG_ERR("check _TDirPatcher_closeOldFileHandles(self) error!\n"); result=hpatch_FALSE; }
+    check(patch_decompress_with_cache(out_newData,oldData,&hdiffData.base,
+                                      self->_decompressPlugin,temp_cache,temp_cache_end));
+    check(_TDirPatcher_closeNewFileHandles(self));
+    check(_TDirPatcher_closeOldFileHandles(self));
+clear:
     return result;
 }
 
@@ -615,36 +574,25 @@ hpatch_BOOL TDirPatcher_close(TDirPatcher* self){
 
 
 
-const char* TDirPatcher_getOldPathByNewPath(const TDirPatcher* self,const char* newPath,
-                                            char* out_pathBuf,char* out_pathBufEnd){
-    assert(out_pathBuf!=newPath);
-    if (!setPathWithRoot(out_pathBuf,out_pathBufEnd,self->_oldRootDir,self->_oldRootDir_len,
-                         newPath+self->_newDir._newRootDir_len)) return 0; //error
-    return out_pathBuf;
+const char* TDirPatcher_getOldPathByNewPath(TDirPatcher* self,const char* newPath){
+    assert(self->_newDir._newRootDir==newPath);
+    if (!setPath(self->_oldRootDir_end,self->_oldRootDir_bufEnd,
+                 self->_newDir._newRootDir_end)) return 0; //error
+    return self->_oldRootDir;
 }
 
-const char* TDirPatcher_getOldPathByIndex(const TDirPatcher* self,size_t oldPathIndex,
-                                          char* out_pathBuf,char* out_pathBufEnd){
+const char* TDirPatcher_getOldPathByIndex(TDirPatcher* self,size_t oldPathIndex){
     assert(oldPathIndex<self->dirDiffHead.oldPathCount);
-    if (!setPathWithRoot(out_pathBuf,out_pathBufEnd,self->_oldRootDir,self->_oldRootDir_len,
-                         self->oldUtf8PathList[oldPathIndex])) return 0; //error
-    return out_pathBuf;
+    if (!setPath(self->_oldRootDir_end,self->_oldRootDir_bufEnd,
+                 self->oldUtf8PathList[oldPathIndex])) return 0; //error
+    return self->_oldRootDir;
 }
 
-const char* TDirPatcher_getOldRefPathByRefIndex(const TDirPatcher* self,size_t oldRefIndex,
-                                                char* out_pathBuf,char* out_pathBufEnd){
+const char* TDirPatcher_getOldRefPathByRefIndex(TDirPatcher* self,size_t oldRefIndex){
     assert(oldRefIndex<self->dirDiffHead.oldRefFileCount);
-    return TDirPatcher_getOldPathByIndex(self,self->oldRefList[oldRefIndex],out_pathBuf,out_pathBufEnd);
+    return TDirPatcher_getOldPathByIndex(self,self->oldRefList[oldRefIndex]);
 }
 
-const char* TDirPatcher_getOldExecuteFileByNewExecuteIndex(const TDirPatcher* self,size_t newExecuteIndex,
-                                                           char* out_pathBuf,char* out_pathBufEnd){
-    char _tmpPath[hpatch_kPathMaxSize];
-    const char* executeFileName_in_new=TDirPatcher_getNewExecuteFileByIndex(self,newExecuteIndex,_tmpPath,_tmpPath+sizeof(_tmpPath));
-    return TDirPatcher_getOldPathByNewPath(self,executeFileName_in_new,out_pathBuf,out_pathBufEnd);
-}
-
-
 hpatch_BOOL TDirPatcher_initOldSameRefCount(TDirPatcher* self){
     size_t* counts;
     size_t  i;
@@ -714,9 +662,8 @@ hpatch_BOOL TDirOldDataChecksum_append(TDirOldDataChecksum* self,unsigned char*
             return hpatch_TRUE;//need more diffData
         }
         mem_as_hStreamInput(&self->_diffStream,self->_partDiffData,self->_partDiffData_cur);
-        checki(_read_dirdiff_head(&self->_dirPatcher.dirDiffInfo,&self->_dirPatcher.dirDiffHead,
-                                  &self->_diffStream,out_isAppendContinue),
-               "TDirOldDataChecksum_append() _read_dirdiff_head");
+        check(_read_dirdiff_head(&self->_dirPatcher.dirDiffInfo,&self->_dirPatcher.dirDiffHead,
+                                 &self->_diffStream,out_isAppendContinue));
         if (*out_isAppendContinue){
             memset(&self->_dirPatcher.dirDiffInfo,0,sizeof(self->_dirPatcher.dirDiffInfo));
             memset(&self->_dirPatcher.dirDiffHead,0,sizeof(self->_dirPatcher.dirDiffHead));
@@ -752,10 +699,9 @@ const char* TDirOldDataChecksum_getCompressType(const TDirOldDataChecksum* self)
     return self->_dirPatcher.dirDiffInfo.hdiffInfo.compressType;
 }
 
-    typedef const char* (*_t_getPathByIndex)(const TDirPatcher* self,size_t index,char* out_pathBuf,char* out_pathBufEnd);
+    typedef const char* (*_t_getPathByIndex)(TDirPatcher* self,size_t index);
 static hpatch_BOOL _do_checksumFiles(TDirPatcher* self,size_t fileCount,_t_getPathByIndex getPathByIndex,
-                                     const TByte* checksumTest,hpatch_StreamPos_t sumFileSizeTest,
-			                	     hpatch_byte* tempBuf,hpatch_byte* tempBufEnd){
+                                     const TByte* checksumTest,hpatch_StreamPos_t sumFileSizeTest){
     hpatch_BOOL result=hpatch_TRUE;
     hpatch_StreamPos_t      sumFileSize=0;
     size_t                  i;
@@ -766,18 +712,13 @@ static hpatch_BOOL _do_checksumFiles(TDirPatcher* self,size_t fileCount,_t_getPa
     hpatch_TFileStreamInput fileData;
     
     hpatch_TFileStreamInput_init(&fileData);
-    check(tempBuf);
     if (checksumPlugin) checksumPlugin->begin(csHandle);
     for (i=0;i<fileCount;++i) {
-        {
-            char _tmpPath[hpatch_kPathMaxSize];
-            const char* fileName=getPathByIndex(self,i,_tmpPath,_tmpPath+hpatch_kPathMaxSize);
-            check(hpatch_TFileStreamInput_open(&fileData,fileName));
-        }
+        const char* fileName=getPathByIndex(self,i);
+        check(hpatch_TFileStreamInput_open(&fileData,fileName));
         sumFileSize+=fileData.base.streamSize;
-        if (checksumPlugin) checki(_checksum_append(checksumPlugin,csHandle,&fileData.base,
-                                                    0,fileData.base.streamSize,tempBuf,tempBufEnd),
-                                   "_do_checksumFiles() _checksum_append");
+        if (checksumPlugin) check(_checksum_append(checksumPlugin,csHandle,
+                                                   &fileData.base,0,fileData.base.streamSize));
         check(hpatch_TFileStreamInput_close(&fileData));
     }
     check(sumFileSize==sumFileSizeTest);
@@ -787,7 +728,6 @@ static hpatch_BOOL _do_checksumFiles(TDirPatcher* self,size_t fileCount,_t_getPa
     }
 clear:
     if (!hpatch_TFileStreamInput_close(&fileData)) result=hpatch_FALSE;
-    mix_ferr(self->fileError,fileData.fileError);
     if (csHandle) checksumPlugin->close(checksumPlugin,csHandle);
     return result;
 }
@@ -795,9 +735,6 @@ clear:
 hpatch_BOOL TDirOldDataChecksum_checksum(TDirOldDataChecksum* self,hpatch_TDecompress* decompressPlugin,
                                          hpatch_TChecksum* checksumPlugin,const char* oldPath_utf8){
     hpatch_BOOL result=hpatch_TRUE;
-    const hpatch_size_t     kTempBufSize=hpatch_kFileIOBufBetterSize*2;
-    hpatch_byte*            tempBuf=(hpatch_byte*)malloc(kTempBufSize);
-    checki(tempBuf,"malloc()");
     check(self->_isOpened&&self->_isAppendStoped);
     if (checksumPlugin){
         TDirPatchChecksumSet checksumSet;
@@ -805,22 +742,19 @@ hpatch_BOOL TDirOldDataChecksum_checksum(TDirOldDataChecksum* self,hpatch_TDecom
         checksumSet.checksumPlugin=checksumPlugin;
         checksumSet.isCheck_oldRefData=hpatch_TRUE;
         checksumSet.isCheck_copyFileData=hpatch_TRUE;
-        check(TDirPatcher_checksum(&self->_dirPatcher,&checksumSet,tempBuf,tempBuf+kTempBufSize));
+        check(TDirPatcher_checksum(&self->_dirPatcher,&checksumSet));
     }
     check(TDirPatcher_loadDirData(&self->_dirPatcher,decompressPlugin,oldPath_utf8,""));
     
     //old copy files
-    checki(_do_checksumFiles(&self->_dirPatcher,self->_dirPatcher.dirDiffHead.sameFilePairCount,
-                             TDirPatcher_getOldPathBySameIndex,_pchecksumCopyFile(&self->_dirPatcher),
-                             self->_dirPatcher.dirDiffHead.sameFileSize,tempBuf,tempBuf+kTempBufSize),
-           "TDirOldDataChecksum_checksum() _do_checksumFiles old");
+    check(_do_checksumFiles(&self->_dirPatcher,self->_dirPatcher.dirDiffHead.sameFilePairCount,
+                            TDirPatcher_getOldPathBySameIndex,_pchecksumCopyFile(&self->_dirPatcher),
+                            self->_dirPatcher.dirDiffHead.sameFileSize));
     //oldRef files
-    checki(_do_checksumFiles(&self->_dirPatcher,self->_dirPatcher.dirDiffHead.oldRefFileCount,
-                             TDirPatcher_getOldRefPathByRefIndex,_pchecksumOldRef(&self->_dirPatcher),
-                             self->_dirPatcher.dirDiffInfo.hdiffInfo.oldDataSize,tempBuf,tempBuf+kTempBufSize),
-           "TDirOldDataChecksum_checksum() _do_checksumFiles oldRef");
+    check(_do_checksumFiles(&self->_dirPatcher,self->_dirPatcher.dirDiffHead.oldRefFileCount,
+                            TDirPatcher_getOldRefPathByRefIndex,_pchecksumOldRef(&self->_dirPatcher),
+                            self->_dirPatcher.dirDiffInfo.hdiffInfo.oldDataSize));
 clear:
-    if (tempBuf) free(tempBuf);
     return result;
 }