react-native-update 10.34.3 → 10.34.4

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

@@ -29,16 +29,8 @@
 #ifndef DirPatch_dir_patch_h
 #define DirPatch_dir_patch_h
 #include "dir_patch_types.h"
-#include "../../libHDiffPatch/HPatch/checksum_plugin.h"
-    typedef struct TDirPatchChecksumSet{
-        hpatch_TChecksum*   checksumPlugin;
-        hpatch_BOOL         isCheck_oldRefData;
-        hpatch_BOOL         isCheck_newRefData;  
-        hpatch_BOOL         isCheck_copyFileData;
-        hpatch_BOOL         isCheck_dirDiffData;
-    } TDirPatchChecksumSet;
-
 #if (_IS_NEED_DIR_DIFF_PATCH)
+#include "../../libHDiffPatch/HPatch/checksum_plugin.h"
 #include "ref_stream.h"
 #include "new_stream.h"
 #include "res_handle_limit.h"
@@ -54,10 +46,6 @@ typedef struct TDirDiffInfo{
     hpatch_BOOL                 dirDataIsCompressed;
     //compressType saved in hdiffInfo
     hpatch_compressedDiffInfo   hdiffInfo;
-#if (_IS_NEED_SINGLE_STREAM_DIFF)
-    hpatch_BOOL         isSingleCompressedDiff;
-    hpatch_singleCompressedDiffInfo sdiffInfo;
-#endif
     hpatch_StreamPos_t          externDataOffset;
     hpatch_StreamPos_t          externDataSize;
     hpatch_StreamPos_t          checksumOffset;
@@ -66,13 +54,13 @@ typedef struct TDirDiffInfo{
 } TDirDiffInfo;
 
 
-hpatch_BOOL getDirDiffInfo(TDirDiffInfo* out_info,const hpatch_TStreamInput* diffFile);
-hpatch_BOOL getDirDiffInfoByFile(TDirDiffInfo* out_info,const char* diffFileName,
+hpatch_BOOL getDirDiffInfo(const hpatch_TStreamInput* diffFile,TDirDiffInfo* out_info);
+hpatch_BOOL getDirDiffInfoByFile(const char* diffFileName,TDirDiffInfo* out_info,
                                  hpatch_StreamPos_t diffDataOffert,hpatch_StreamPos_t diffDataSize);
 static hpatch_inline
 hpatch_BOOL getIsDirDiffFile(const char* diffFileName){
      TDirDiffInfo dirDiffInfo;
-    if (!getDirDiffInfoByFile(&dirDiffInfo,diffFileName,0,0)) return hpatch_FALSE;
+    if (!getDirDiffInfoByFile(diffFileName,&dirDiffInfo,0,0)) return hpatch_FALSE;
     return dirDiffInfo.isDirDiff;
 }
 
@@ -101,6 +89,14 @@ hpatch_BOOL getIsDirDiffFile(const char* diffFileName){
     struct hpatch_TFileStreamInput;
     struct hpatch_TFileStreamOutput;
     
+    typedef struct TDirPatchChecksumSet{
+        hpatch_TChecksum*   checksumPlugin;
+        hpatch_BOOL         isCheck_oldRefData;
+        hpatch_BOOL         isCheck_newRefData;  
+        hpatch_BOOL         isCheck_copyFileData;
+        hpatch_BOOL         isCheck_dirDiffData;
+    } TDirPatchChecksumSet;
+    
 typedef struct TDirPatcher{
     TDirDiffInfo                dirDiffInfo;
     _TDirDiffHead               dirDiffHead;
@@ -115,8 +111,9 @@ typedef struct TDirPatcher{
     hpatch_TResHandleLimit      _resLimit;
     hpatch_IResHandle*          _resList;
     struct hpatch_TFileStreamInput*    _oldFileList;
-    const char*                 _oldRootDir;
-    size_t                      _oldRootDir_len;
+    char*                       _oldRootDir;
+    char*                       _oldRootDir_end;
+    char*                       _oldRootDir_bufEnd;
     void*                       _pOldRefMem;
     
     hpatch_ICopyDataListener    _sameFileCopyListener;
@@ -128,7 +125,6 @@ typedef struct TDirPatcher{
     const hpatch_TStreamInput*  _dirDiffData;
     void*                       _pDiffDataMem;
     size_t*                     _pOldSameRefCount;
-    hpatch_FileError_t          fileError;
 } TDirPatcher;
 
 hpatch_inline
@@ -136,8 +132,7 @@ static void TDirPatcher_init(TDirPatcher* self)  { memset(self,0,sizeof(*self));
 hpatch_BOOL TDirPatcher_open(TDirPatcher* self,const hpatch_TStreamInput* dirDiffData,
                              const TDirDiffInfo** out_dirDiffInfo);
 //if checksumSet->isCheck_dirDiffData then result&=checksum(dirDiffData);
-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 TDirPatcher_loadDirData(TDirPatcher* self,hpatch_TDecompress* decompressPlugin,
                                     const char* oldPath_utf8,const char* newPath_utf8);
 
@@ -147,7 +142,7 @@ hpatch_BOOL TDirPatcher_openNewDirAsStream(TDirPatcher* self,IDirPatchListener*
                                            const hpatch_TStreamOutput** out_newDirStream);
 hpatch_BOOL TDirPatcher_patch(TDirPatcher* self,const hpatch_TStreamOutput* out_newData,
                               const hpatch_TStreamInput* oldData,
-                              unsigned char* temp_cache,unsigned char* temp_cache_end,size_t threadNum);
+                              unsigned char* temp_cache,unsigned char* temp_cache_end);
     
 static hpatch_inline
 hpatch_BOOL TDirPatcher_isCopyDataChecksumError(const TDirPatcher* self)
@@ -165,50 +160,45 @@ hpatch_BOOL TDirPatcher_isOldRefDataChecksumError(const TDirPatcher* self)
 static hpatch_inline
 size_t      TDirPatcher_getNewExecuteFileCount(const TDirPatcher* self) {
                                                return self->dirDiffHead.newExecuteCount;  }
-static hpatch_inline const char* TDirPatcher_getNewExecuteFileByIndex(const TDirPatcher* self,size_t newExecuteIndex,
-                                                                      char* out_pathBuf,char* out_pathBufEnd)
-    { return TNewDirOutput_getNewExecuteFileByIndex(&self->_newDir,newExecuteIndex,out_pathBuf,out_pathBufEnd); }
+static hpatch_inline const char* TDirPatcher_getNewExecuteFileByIndex(TDirPatcher* self,size_t newExecuteIndex)
+    { return TNewDirOutput_getNewExecuteFileByIndex(&self->_newDir,newExecuteIndex); }
 
 hpatch_BOOL TDirPatcher_closeOldRefStream(TDirPatcher* self);//for TDirPatcher_openOldRefAsStream
 hpatch_BOOL TDirPatcher_closeNewDirStream(TDirPatcher* self);//for TDirPatcher_openNewDirAsStream
 hpatch_BOOL TDirPatcher_close(TDirPatcher* self);
 
 //can be called after TDirPatcher_loadDirData
-const char* TDirPatcher_getOldPathByIndex(const TDirPatcher* self,size_t oldPathIndex,
-                                          char* out_pathBuf,char* out_pathBufEnd);
-const char* TDirPatcher_getOldRefPathByRefIndex(const TDirPatcher* self,size_t oldRefIndex,
-                                                char* out_pathBuf,char* out_pathBufEnd);
-const char* TDirPatcher_getOldPathByNewPath(const TDirPatcher* self,const char* newPath,
-                                            char* out_pathBuf,char* out_pathBufEnd);
-static hpatch_inline const char* TDirPatcher_getNewPathRoot(const TDirPatcher* self)
+const char* TDirPatcher_getOldPathByIndex(TDirPatcher* self,size_t oldPathIndex);
+const char* TDirPatcher_getOldRefPathByRefIndex(TDirPatcher* self,size_t oldRefIndex);
+const char* TDirPatcher_getOldPathByNewPath(TDirPatcher* self,const char* newPath);
+static hpatch_inline const char* TDirPatcher_getNewPathRoot(TDirPatcher* self)
     { return TNewDirOutput_getNewPathRoot(&self->_newDir); }
-static hpatch_inline const char* TDirPatcher_getNewPathByIndex(const TDirPatcher* self,size_t newPathIndex,
-                                                               char* out_pathBuf,char* out_pathBufEnd)
-    { return TNewDirOutput_getNewPathByIndex(&self->_newDir,newPathIndex,out_pathBuf,out_pathBufEnd); }
-static hpatch_inline const char* TDirPatcher_getOldPathBySameIndex(const TDirPatcher* self,size_t sameIndex,
-                                                                   char* out_pathBuf,char* out_pathBufEnd)
-    { return TNewDirOutput_getOldPathBySameIndex(&self->_newDir,sameIndex,out_pathBuf,out_pathBufEnd); }
-static hpatch_inline const char* TDirPatcher_getNewPathBySameIndex(const TDirPatcher* self,size_t sameIndex,
-                                                                   char* out_pathBuf,char* out_pathBufEnd)
-    { return TNewDirOutput_getNewPathBySameIndex(&self->_newDir,sameIndex,out_pathBuf,out_pathBufEnd); }
+static hpatch_inline const char* TDirPatcher_getNewPathByIndex(TDirPatcher* self,size_t newPathIndex)
+    { return TNewDirOutput_getNewPathByIndex(&self->_newDir,newPathIndex); }
+static hpatch_inline const char* TDirPatcher_getOldPathBySameIndex(TDirPatcher* self,size_t sameIndex)
+    { return TNewDirOutput_getOldPathBySameIndex(&self->_newDir,sameIndex); }
+static hpatch_inline const char* TDirPatcher_getNewPathBySameIndex(TDirPatcher* self,size_t sameIndex)
+    { return TNewDirOutput_getNewPathBySameIndex(&self->_newDir,sameIndex); }
 static hpatch_inline void TDirPatcher_getNewExecuteList(TDirPatcher* self,IDirPathList* out_executeList)
     { TNewDirOutput_getExecuteList(&self->_newDir,out_executeList); }
 static hpatch_inline void TDirPatcher_getNewDirPathList(TDirPatcher* self,IDirPathList* out_newPathList)
     { TNewDirOutput_getNewDirPathList(&self->_newDir,out_newPathList); }
-static hpatch_inline void TDirPatcher_getOldDirPathList(TDirPatcher* self,IDirPathList* out_oldPathList){
-    out_oldPathList->import=self;
+static hpatch_inline void TDirPatcher_getOldDirPathList(TDirPatcher* self,IDirPathList* out_oldPathList){ out_oldPathList->import=self;
     out_oldPathList->pathCount=self->dirDiffHead.oldPathCount;
     out_oldPathList->getPathNameByIndex=(IDirPathList_getPathNameByIndex)TDirPatcher_getOldPathByIndex;
 }
-const char* TDirPatcher_getOldExecuteFileByNewExecuteIndex(const TDirPatcher* self,size_t newExecuteIndex,
-                                                           char* out_pathBuf,char* out_pathBufEnd);
+
+static hpatch_inline
+const char* TDirPatcher_getOldExecuteFileByNewExecuteIndex(TDirPatcher* self,size_t newExecuteIndex){
+    const char* executeFileName_in_new=TDirPatcher_getNewExecuteFileByIndex(self,newExecuteIndex);
+    return TDirPatcher_getOldPathByNewPath(self,executeFileName_in_new);
+}
+
 
 hpatch_BOOL TDirPatcher_initOldSameRefCount(TDirPatcher* self);
 void        TDirPatcher_finishOldSameRefCount(TDirPatcher* self);
-const char* TDirPatcher_getOldPathBySameIndex(const TDirPatcher* self,size_t sameIndex,
-                                              char* out_pathBuf,char* out_pathBufEnd);
-const char* TDirPatcher_getNewPathBySameIndex(const TDirPatcher* self,size_t sameIndex,
-                                              char* out_pathBuf,char* out_pathBufEnd);
+const char* TDirPatcher_getOldPathBySameIndex(TDirPatcher* self,size_t sameIndex);
+const char* TDirPatcher_getNewPathBySameIndex(TDirPatcher* self,size_t sameIndex);
 size_t      TDirPatcher_oldSameRefCount(TDirPatcher* self,size_t sameIndex);
 void        TDirPatcher_decOldSameRefCount(TDirPatcher* self,size_t sameIndex);
     

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

@@ -34,7 +34,7 @@
 
 #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; } }
 
 void formatDirTagForLoad(char* utf8_path,char* utf8_pathEnd){
@@ -63,8 +63,7 @@ hpatch_BOOL readListTo(TStreamCacheClip* sclip,hpatch_StreamPos_t* out_list,size
     hpatch_BOOL result=hpatch_TRUE;
     size_t i;
     for (i=0; i<count; ++i) {
-        checki(_TStreamCacheClip_unpackUIntWithTag(sclip,&out_list[i],0),
-               "readListTo() saved data");
+        check(_TStreamCacheClip_unpackUIntWithTag(sclip,&out_list[i],0));
     }
 clear:
     return result;
@@ -78,31 +77,32 @@ hpatch_BOOL readIncListTo(TStreamCacheClip* sclip,size_t* out_list,
     size_t i;
     for (i=0; i<count; ++i) {
         TUInt incValue;
-        checki(_TStreamCacheClip_unpackUIntWithTag(sclip,&incValue,0),"readIncListTo() saved data");
+        check(_TStreamCacheClip_unpackUIntWithTag(sclip,&incValue,0));
         backValue+=1+incValue;
-        checki(backValue<check_endValue,"readIncListTo() saved data value");
+        check(backValue<check_endValue);
         out_list[i]=(size_t)backValue;
     }
 clear:
     return result;
 }
 
-char* _setPath(char* out_path,char* out_pathBufEnd,const char* fileName,size_t fileNameLen){
+char* setPath(char* out_path,char* out_pathBufEnd,const char* fileName){
     char* result=0; //false
-    checki(fileNameLen+1<=(size_t)(out_pathBufEnd-out_path),"_setPath() out_path buf size");
-    memcpy(out_path,fileName,fileNameLen+1);//with '\0'
-    result=out_path+fileNameLen;
+    size_t strLen=strlen(fileName);
+    check(strLen+1<=(size_t)(out_pathBufEnd-out_path));
+    memcpy(out_path,fileName,strLen+1);//with '\0'
+    result=out_path+strLen;
 clear:
     return result;
 }
 
-char* _setDirPath(char* out_path,char* out_pathBufEnd,const char* dirName,size_t dirNameLen){
+char* setDirPath(char* out_path,char* out_pathBufEnd,const char* dirName){
     char* result=0; //false
-    hpatch_BOOL isNeedDirSeparator=(dirNameLen>0)&&(dirName[dirNameLen-1]!=kPatch_dirSeparator);
-    checki((dirNameLen+(isNeedDirSeparator?1:0)+1)<=(size_t)(out_pathBufEnd-out_path),
-           "_setDirPath() out_path buf size");
-    memcpy(out_path,dirName,dirNameLen);
-    result=out_path+dirNameLen;
+    size_t strLen=strlen(dirName);
+    hpatch_BOOL isNeedDirSeparator=(strLen>0)&&(dirName[strLen-1]!=kPatch_dirSeparator);
+    check((strLen+(isNeedDirSeparator?1:0)+1)<=(size_t)(out_pathBufEnd-out_path));
+    memcpy(out_path,dirName,strLen);
+    result=out_path+strLen;
     if (isNeedDirSeparator) { *result=kPatch_dirSeparator; ++result; }
     *result='\0'; //C string end
 clear:

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/dir_patch_tools.h

@@ -41,26 +41,10 @@ extern "C" {
     hpatch_BOOL readIncListTo(TStreamCacheClip* sclip,size_t* out_list,
                               size_t count,size_t check_endValue);
     
-    char* _setPath(char* out_path,char* out_pathBufEnd,const char* fileName,size_t fileNameLen);
     //return path end pos
-    static hpatch_force_inline
-    char* setPath(char* out_path,char* out_pathBufEnd,const char* fileName){ 
-                    return _setPath(out_path,out_pathBufEnd,fileName,strlen(fileName)); }
-    static hpatch_force_inline
-    char* setPathWithRoot(char* out_path,char* out_pathBufEnd,const char* root_path,size_t root_pathLen,const char* fileName){
-                                char* resultEnd=_setPath(out_path,out_pathBufEnd,root_path,root_pathLen);
-                                if (resultEnd) resultEnd=setPath(resultEnd,out_pathBufEnd,fileName);
-                                return resultEnd;   }
+    char* setPath(char* out_path,char* out_pathBufEnd,const char* fileName);
+    char* setDirPath(char* out_path,char* out_pathBufEnd,const char* dirName);
 
-    char* _setDirPath(char* out_path,char* out_pathBufEnd,const char* dirName,size_t dirNameLen);
-    static hpatch_force_inline
-    char* setDirPath(char* out_path,char* out_pathBufEnd,const char* dirName){
-                        return _setDirPath(out_path,out_pathBufEnd,dirName,strlen(dirName)); }
-    static hpatch_force_inline
-    char* setDirPathWithRoot(char* out_path,char* out_pathBufEnd,char* root_path,size_t root_pathLen,const char* dirName){
-                                    char* resultEnd=_setPath(out_path,out_pathBufEnd,root_path,root_pathLen);
-                                    if (resultEnd) resultEnd=setDirPath(resultEnd,out_pathBufEnd,dirName);
-                                    return resultEnd;  }
     
 #ifdef __cplusplus
 }

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/dir_patch_types.h

@@ -32,19 +32,15 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-
+    
 #ifndef _IS_NEED_DIR_DIFF_PATCH
 #   define _IS_NEED_DIR_DIFF_PATCH  1
 #endif
-#ifndef _IS_NEED_SINGLE_STREAM_DIFF
-#   define _IS_NEED_SINGLE_STREAM_DIFF 1
-#endif
-
 
 #if (_IS_NEED_DIR_DIFF_PATCH)
-#   define kMaxOpenFileNumber_limit_min          5
-#   define kMaxOpenFileNumber_default_min       16 //must >= limit_min
-#   define kMaxOpenFileNumber_default_diff      64
+#   define kMaxOpenFileNumber_limit_min          4
+#   define kMaxOpenFileNumber_default_min        8 //must >= limit_min
+#   define kMaxOpenFileNumber_default_diff      48
 #   define kMaxOpenFileNumber_default_patch     24
 #endif
 

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

@@ -35,13 +35,12 @@
 
 #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)
 
 static hpatch_BOOL _TDirPatcher_copyFile(const char* oldFileName_utf8,const char* newFileName_utf8,
-                                         hpatch_ICopyDataListener* copyListener,hpatch_FileError_t* out_fileError){
-#define _tempCacheSize hpatch_kFileIOBufBetterSize
+                                         hpatch_ICopyDataListener* copyListener){
+#define _tempCacheSize (hpatch_kStreamCacheSize*4)
     hpatch_BOOL result=hpatch_TRUE;
     TByte        temp_cache[_tempCacheSize];
     hpatch_StreamPos_t pos=0;
@@ -64,61 +63,48 @@ static hpatch_BOOL _TDirPatcher_copyFile(const char* oldFileName_utf8,const char
             copyListener->copyedData(copyListener,temp_cache,temp_cache+copyLen);
         pos+=copyLen;
     }
+    check(!oldFile.fileError);
+    check(!newFile.fileError);
     if (newFileName_utf8)
         check(newFile.out_length==newFile.base.streamSize);
 clear:
-    if (newFile.fileError) { result=hpatch_FALSE; set_ferr(*out_fileError,newFile.fileError); }
-    if (oldFile.fileError) { result=hpatch_FALSE; set_ferr(*out_fileError,oldFile.fileError); }
-    if (!hpatch_TFileStreamOutput_close(&newFile)){
-        result=hpatch_FALSE; mix_ferr(*out_fileError,newFile.fileError); }
-    if (!hpatch_TFileStreamInput_close(&oldFile)){
-        result=hpatch_FALSE; mix_ferr(*out_fileError,oldFile.fileError); }
+    hpatch_TFileStreamOutput_close(&newFile);
+    hpatch_TFileStreamInput_close(&oldFile);
     return result;
 #undef _tempCacheSize
 }
 
 hpatch_BOOL TDirPatcher_copyFile(const char* oldFileName_utf8,const char* newFileName_utf8,
-                                 hpatch_ICopyDataListener* copyListener,hpatch_FileError_t* out_fileError){
+                                 hpatch_ICopyDataListener* copyListener){
     hpatch_BOOL result=hpatch_TRUE;
     check(newFileName_utf8!=0);
-    result=_TDirPatcher_copyFile(oldFileName_utf8,newFileName_utf8,copyListener,out_fileError);
+    result=_TDirPatcher_copyFile(oldFileName_utf8,newFileName_utf8,copyListener);
 clear:
     return result;
 }
-hpatch_BOOL TDirPatcher_readFile(const char* oldFileName_utf8,hpatch_ICopyDataListener* copyListener,hpatch_FileError_t* out_fileError){
-    return _TDirPatcher_copyFile(oldFileName_utf8,0,copyListener,out_fileError);
-}
-
-
-static hpatch_BOOL _tryCloseNewFile(TNewDirOutput* self){
-    hpatch_BOOL result;
-    hpatch_FileError_t fileError;
-    if (self->_curNewFile==0) return hpatch_TRUE;
-    result=self->_listener->closeNewFile(self->_listener,self->_curNewFile);
-    fileError=self->_curNewFile->fileError;
-    hpatch_TFileStreamOutput_init(self->_curNewFile);
-    return result&&(!fileError);
+hpatch_BOOL TDirPatcher_readFile(const char* oldFileName_utf8,hpatch_ICopyDataListener* copyListener){
+    return _TDirPatcher_copyFile(oldFileName_utf8,0,copyListener);
 }
 
 static hpatch_BOOL _makeNewDirOrEmptyFile(hpatch_INewStreamListener* listener,size_t newPathIndex){
     hpatch_BOOL  result=hpatch_TRUE;
     TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
-    char _tmpPath[hpatch_kPathMaxSize];
-    const char*  pathName=TNewDirOutput_getNewPathByIndex(self,newPathIndex,_tmpPath,_tmpPath+sizeof(_tmpPath));
+    const char*  pathName=TNewDirOutput_getNewPathByIndex(self,newPathIndex);
     check(pathName!=0);
     if (hpatch_getIsDirName(pathName)){ //
         check(self->_listener->makeNewDir(self->_listener,pathName));
     }else{ //empty file
         check(self->_listener->openNewFile(self->_listener,self->_curNewFile,pathName,0));
-        check(_tryCloseNewFile(self));
+        check(!self->_curNewFile->fileError);
+        check(self->_listener->closeNewFile(self->_listener,self->_curNewFile));
     }
 clear:
     return result;
 }
 
-static const char* _getOldPathByIndex(const TNewDirOutput* self,size_t oldPathIndex,char* out_pathBuf,char* out_pathBufEnd){
+static const char* _getOldPathByIndex(TNewDirOutput* self,size_t oldPathIndex){
     assert(self->_oldPathListener.getOldPathByIndex!=0);
-    return self->_oldPathListener.getOldPathByIndex(&self->_oldPathListener,oldPathIndex,out_pathBuf,out_pathBufEnd);
+    return self->_oldPathListener.getOldPathByIndex(&self->_oldPathListener,oldPathIndex);
 }
 
 static hpatch_BOOL _copySameFile(hpatch_INewStreamListener* listener,size_t newPathIndex,size_t oldPathIndex){
@@ -126,17 +112,14 @@ static hpatch_BOOL _copySameFile(hpatch_INewStreamListener* listener,size_t newP
     TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
     const char*  newFileName=0;
     const char*  oldFileName=0;
-    char _tmpPath0[hpatch_kPathMaxSize];
-    char _tmpPath1[hpatch_kPathMaxSize];
     assert(newPathIndex<self->newPathCount);
-    newFileName=TNewDirOutput_getNewPathByIndex(self,newPathIndex,_tmpPath0,_tmpPath0+sizeof(_tmpPath0));
+    newFileName=TNewDirOutput_getNewPathByIndex(self,newPathIndex);
     check(newFileName!=0);
     check(self->_oldPathListener.getOldPathByIndex!=0);
-    oldFileName=_getOldPathByIndex(self,oldPathIndex,_tmpPath1,_tmpPath1+sizeof(_tmpPath1));
+    oldFileName=_getOldPathByIndex(self,oldPathIndex);
     check(oldFileName!=0);
-    checki(self->_listener->copySameFile(self->_listener,oldFileName,newFileName,
-                                         self->isCheck_copyFileData?(&self->_sameFileCopyListener):0),
-           "_copySameFile() copySameFile");
+    check(self->_listener->copySameFile(self->_listener,oldFileName,newFileName,
+                                        self->isCheck_copyFileData?(&self->_sameFileCopyListener):0));
 clear:
     return result;
 }
@@ -145,20 +128,19 @@ static hpatch_BOOL _openNewFile(hpatch_INewStreamListener* listener,size_t newRe
                                 const hpatch_TStreamOutput** out_newFileStream){
     hpatch_BOOL  result=hpatch_TRUE;
     TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
-    hpatch_StreamPos_t fileSize;
-    assert((newRefIndex<self->newRefFileCount)&&(self->_curNewFile->base.write==0));
-    fileSize=self->newRefSizeList[newRefIndex];
+    const char*  utf8fileName=0;
+    hpatch_StreamPos_t fileSize=self->newRefSizeList[newRefIndex];
+    assert(newRefIndex<self->newRefFileCount);
+    assert(self->_curNewFile->m_file==0);
     if (fileSize==0){
         size_t newPathIndex=self->newRefList?self->newRefList[newRefIndex]:newRefIndex;
         check(_makeNewDirOrEmptyFile(listener,newPathIndex));
         *out_newFileStream=0;
     }else{
-        char _tmpPath[hpatch_kPathMaxSize];
-        const char*  utf8fileName=TNewDirOutput_getNewPathByRefIndex(self,newRefIndex,_tmpPath,_tmpPath+sizeof(_tmpPath));
+        utf8fileName=TNewDirOutput_getNewPathByRefIndex(self,newRefIndex);
         check(utf8fileName!=0);
-        checki(self->_listener->openNewFile(self->_listener,self->_curNewFile,
-                                            utf8fileName,fileSize),
-               "_openNewFile() openNewFile");
+        check(self->_listener->openNewFile(self->_listener,self->_curNewFile,
+                                           utf8fileName,fileSize));
         *out_newFileStream=&self->_curNewFile->base;
     }
 clear:
@@ -167,8 +149,11 @@ clear:
 static hpatch_BOOL _closeNewFile(hpatch_INewStreamListener* listener,const hpatch_TStreamOutput* newFileStream){
     hpatch_BOOL  result=hpatch_TRUE;
     TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
-    assert((self->_curNewFile!=0)&&(newFileStream==&self->_curNewFile->base));
-    check(_tryCloseNewFile(self));
+    assert(self->_curNewFile!=0);
+    assert(newFileStream==&self->_curNewFile->base);
+    check(!self->_curNewFile->fileError);
+    check(self->_listener->closeNewFile(self->_listener,self->_curNewFile));
+    hpatch_TFileStreamOutput_init(self->_curNewFile);
 clear:
     return result;
 }
@@ -263,11 +248,10 @@ hpatch_BOOL TNewDirOutput_openDir(TNewDirOutput* self,IDirPatchListener* listene
             self->_sameFileCopyListener.copyedData=_sameFile_copyedData;
         }
     }
-    checki(hpatch_TNewStream_open(&self->_newDirStream,&self->_newDirStreamListener,
-                                  self->newDataSize,self->newPathCount,
-                                  self->newRefList,refCount,self->dataSamePairList,
-                                  self->sameFilePairCount,kAlignSize),
-           "TNewDirOutput_openDir() hpatch_TNewStream_open");
+    check(hpatch_TNewStream_open(&self->_newDirStream,&self->_newDirStreamListener,
+                                 self->newDataSize,self->newPathCount,
+                                 self->newRefList,refCount,self->dataSamePairList,
+                                 self->sameFilePairCount,kAlignSize));
     *out_newDirStream=self->_newDirStream.stream;
 clear:
     return result;
@@ -276,7 +260,11 @@ clear:
 
 hpatch_BOOL TNewDirOutput_closeNewDirHandles(TNewDirOutput* self){
     hpatch_BOOL result=hpatch_TNewStream_closeFileHandles(&self->_newDirStream);
-    if (!_tryCloseNewFile(self)) result=hpatch_FALSE;
+    if (self->_curNewFile){
+        if (!hpatch_TFileStreamOutput_close(self->_curNewFile))
+            result=hpatch_FALSE;
+        hpatch_TFileStreamOutput_init(self->_curNewFile);
+    }
     return result;
 }
 
@@ -286,7 +274,8 @@ hpatch_BOOL TNewDirOutput_close(TNewDirOutput* self){
     if (!hpatch_TNewStream_close(&self->_newDirStream))
         result=hpatch_FALSE;
     self->_newRootDir=0;
-    self->_newRootDir_len=0;
+    self->_newRootDir_end=0;
+    self->_newRootDir_bufEnd=0;
     self->_curNewFile=0;
     if (self->_newRefChecksumHandle){
         checksumPlugin->close(checksumPlugin,self->_newRefChecksumHandle);
@@ -303,44 +292,40 @@ hpatch_BOOL TNewDirOutput_close(TNewDirOutput* self){
     return result;
 }
 
-const char* TNewDirOutput_getNewPathRoot(const TNewDirOutput* self){
+const char* TNewDirOutput_getNewPathRoot(TNewDirOutput* self){
+    if (!setPath(self->_newRootDir_end,self->_newRootDir_bufEnd,"")) return 0; //error
     return self->_newRootDir;
 }
 
-const char* TNewDirOutput_getNewPathByIndex(const TNewDirOutput* self,size_t newPathIndex,
-                                            char* out_pathBuf,char* out_pathBufEnd){
+const char* TNewDirOutput_getNewPathByIndex(TNewDirOutput* self,size_t newPathIndex){
     assert(newPathIndex<self->newPathCount);
-    if (!setPathWithRoot(out_pathBuf,out_pathBufEnd,self->_newRootDir,self->_newRootDir_len,
-                         self->newUtf8PathList[newPathIndex])) return 0; //error
-    return out_pathBuf;
+    if (!setPath(self->_newRootDir_end,self->_newRootDir_bufEnd,
+                 self->newUtf8PathList[newPathIndex])) return 0; //error
+    return self->_newRootDir;
 }
 
-const char* TNewDirOutput_getNewPathByRefIndex(const TNewDirOutput* self,size_t newRefIndex,
-                                               char* out_pathBuf,char* out_pathBufEnd){
+const char* TNewDirOutput_getNewPathByRefIndex(TNewDirOutput* self,size_t newRefIndex){
     size_t newPathIndex;
     assert(newRefIndex<self->newRefFileCount);
     newPathIndex=self->newRefList?self->newRefList[newRefIndex]:newRefIndex;
-    return TNewDirOutput_getNewPathByIndex(self,newPathIndex,out_pathBuf,out_pathBufEnd);
+    return TNewDirOutput_getNewPathByIndex(self,newPathIndex);
 }
 
-const char* TNewDirOutput_getNewExecuteFileByIndex(const TNewDirOutput* self,size_t newExecuteIndex,
-                                                   char* out_pathBuf,char* out_pathBufEnd){
+const char* TNewDirOutput_getNewExecuteFileByIndex(TNewDirOutput* self,size_t newExecuteIndex){
     assert(newExecuteIndex<self->newExecuteCount);
-    return TNewDirOutput_getNewPathByIndex(self,self->newExecuteList[newExecuteIndex],out_pathBuf,out_pathBufEnd);
+    return TNewDirOutput_getNewPathByIndex(self,self->newExecuteList[newExecuteIndex]);
 }
 
-const char* TNewDirOutput_getOldPathBySameIndex(const TNewDirOutput* self,size_t sameIndex,
-                                                char* out_pathBuf,char* out_pathBufEnd){
+const char* TNewDirOutput_getOldPathBySameIndex(TNewDirOutput* self,size_t sameIndex){
     assert(sameIndex<self->sameFilePairCount);
     assert(self->dataSamePairList!=0);
-    return _getOldPathByIndex(self,self->dataSamePairList[sameIndex].oldIndex,out_pathBuf,out_pathBufEnd);
+    return _getOldPathByIndex(self,self->dataSamePairList[sameIndex].oldIndex);
 }
 
-const char* TNewDirOutput_getNewPathBySameIndex(const TNewDirOutput* self,size_t sameIndex,
-                                                char* out_pathBuf,char* out_pathBufEnd){
+const char* TNewDirOutput_getNewPathBySameIndex(TNewDirOutput* self,size_t sameIndex){
     assert(sameIndex<self->sameFilePairCount);
     assert(self->dataSamePairList!=0);
-    return TNewDirOutput_getNewPathByIndex(self,self->dataSamePairList[sameIndex].newIndex,out_pathBuf,out_pathBufEnd);
+    return TNewDirOutput_getNewPathByIndex(self,self->dataSamePairList[sameIndex].newIndex);
 }
 
 #endif

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/new_dir_output.h

@@ -45,8 +45,8 @@ extern "C" {
     } hpatch_ICopyDataListener;
     
 hpatch_BOOL TDirPatcher_copyFile(const char* oldFileName_utf8,const char* newFileName_utf8,
-                                 hpatch_ICopyDataListener* copyListener,hpatch_FileError_t* out_fileError);
-hpatch_BOOL TDirPatcher_readFile(const char* oldFileName_utf8,hpatch_ICopyDataListener* copyListener,hpatch_FileError_t* out_fileError);
+                                 hpatch_ICopyDataListener* copyListener);
+hpatch_BOOL TDirPatcher_readFile(const char* oldFileName_utf8,hpatch_ICopyDataListener* copyListener);
 
 
     struct hpatch_TFileStreamOutput;
@@ -64,7 +64,7 @@ hpatch_BOOL TDirPatcher_readFile(const char* oldFileName_utf8,hpatch_ICopyDataLi
     
     typedef struct hpatch_IOldPathListener{
         void* listenerImport;
-        const char* (*getOldPathByIndex)(const struct hpatch_IOldPathListener* listener,size_t oldPathIndex,char* out_pathBuf,char* out_pathBufEnd);
+        const char* (*getOldPathByIndex)(struct hpatch_IOldPathListener* listener,size_t oldPathIndex);
     } hpatch_IOldPathListener;
     
     typedef struct TNewDirOutput{
@@ -84,8 +84,9 @@ hpatch_BOOL TDirPatcher_readFile(const char* oldFileName_utf8,hpatch_ICopyDataLi
         hpatch_BOOL                 isCheck_copyFileData;
         //private input:
         hpatch_IOldPathListener     _oldPathListener;
-        const char*                 _newRootDir;
-        size_t                      _newRootDir_len; //==strlen(_newRootDir)
+        char*                       _newRootDir;
+        char*                       _newRootDir_end;
+        char*                       _newRootDir_bufEnd;
         const unsigned char*        _pChecksum_newRefData_copyFileData;
         unsigned char*              _pChecksum_temp;
         hpatch_TChecksum*           _checksumPlugin;
@@ -110,21 +111,15 @@ hpatch_BOOL TNewDirOutput_openDir(TNewDirOutput* self,IDirPatchListener* listene
 hpatch_BOOL TNewDirOutput_closeNewDirHandles(TNewDirOutput* self);//for TNewDirOutput_openDir
 hpatch_BOOL TNewDirOutput_close(TNewDirOutput* self);
 
-const char* TNewDirOutput_getNewPathRoot(const TNewDirOutput* self);
-const char* TNewDirOutput_getNewPathByIndex(const TNewDirOutput* self,size_t newPathIndex,
-                                            char* out_pathBuf,char* out_pathBufEnd);
-const char* TNewDirOutput_getNewExecuteFileByIndex(const TNewDirOutput* self,size_t newExecuteIndex,
-                                                   char* out_pathBuf,char* out_pathBufEnd);
-const char* TNewDirOutput_getNewPathByRefIndex(const TNewDirOutput* self,size_t newRefIndex,
-                                               char* out_pathBuf,char* out_pathBufEnd);
-const char* TNewDirOutput_getOldPathBySameIndex(const TNewDirOutput* self,size_t sameIndex,
-                                                char* out_pathBuf,char* out_pathBufEnd);
-const char* TNewDirOutput_getNewPathBySameIndex(const TNewDirOutput* self,size_t sameIndex,
-                                                char* out_pathBuf,char* out_pathBufEnd);
+const char* TNewDirOutput_getNewPathRoot(TNewDirOutput* self);
+const char* TNewDirOutput_getNewPathByIndex(TNewDirOutput* self,size_t newPathIndex);
+const char* TNewDirOutput_getNewExecuteFileByIndex(TNewDirOutput* self,size_t newExecuteIndex);
+const char* TNewDirOutput_getNewPathByRefIndex(TNewDirOutput* self,size_t newRefIndex);
+const char* TNewDirOutput_getOldPathBySameIndex(TNewDirOutput* self,size_t sameIndex);
+const char* TNewDirOutput_getNewPathBySameIndex(TNewDirOutput* self,size_t sameIndex);
 
 //ExecuteList
-typedef const char* (*IDirPathList_getPathNameByIndex)(const void* import,size_t index,
-                                                       char* out_pathBuf,char* out_pathBufEnd);
+typedef const char* (*IDirPathList_getPathNameByIndex)(void* import,size_t index);
 typedef struct IDirPathList{
     void*                   import;
     size_t                  pathCount;

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

@@ -52,7 +52,7 @@ static hpatch_BOOL _file_append_part(hpatch_TNewStream* self,hpatch_StreamPos_t
                                      const unsigned char* data,const unsigned char* data_end);
 static hpatch_BOOL _file_append_end(hpatch_TNewStream* self);
 
-#define  check(value) { if (!(value)){ LOG_ERR("check "#value" error!\n"); return hpatch_FALSE; } }
+#define  check(value) { if (!(value)){ fprintf(stderr,"check "#value" error!\n"); return hpatch_FALSE; } }
 
 static hpatch_BOOL _TNewStream_write(const hpatch_TStreamOutput* stream,hpatch_StreamPos_t writeToPos,
                                      const unsigned char* data,const unsigned char* data_end){

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/new_stream.h

@@ -47,8 +47,8 @@ typedef struct hpatch_TSameFilePair{
     size_t  oldIndex;
 } hpatch_TSameFilePair;
 
-//externally simulates an output stream;
-//Generate new files and copy files using samePairList, newRefList, etc.
+//对外模拟成一个输出流;
+//利用samePairList、newRefList等生成新文件和copy文件
 typedef struct hpatch_TNewStream{
     const hpatch_TStreamOutput* stream;
     hpatch_BOOL             isFinish;

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

@@ -34,7 +34,7 @@ void hpatch_TRefStream_close(hpatch_TRefStream* self){
     if (self->_buf) { free(self->_buf); self->_buf=0; }
 }
 
-#define  check(value) { if (!(value)){ LOG_ERR("check "#value" error!\n");  \
+#define  check(value) { if (!(value)){ fprintf(stderr,"check "#value" error!\n");  \
                                        result=hpatch_FALSE; goto clear; } }
 
 static hpatch_BOOL _TRefStream_read_do(hpatch_TRefStream* self,hpatch_StreamPos_t readFromPos,
@@ -111,7 +111,7 @@ hpatch_BOOL _createRange(hpatch_TRefStream* self,const hpatch_TStreamInput** ref
     
     self->_refList=refList;
     self->_rangeCount=refCount;
-    self->_buf=malloc(sizeof(hpatch_StreamPos_t)*(self->_rangeCount+1));
+    self->_buf=(unsigned char*)malloc(sizeof(hpatch_StreamPos_t)*(self->_rangeCount+1));
     check(self->_buf!=0);
     self->_rangeEndList=((hpatch_StreamPos_t*)self->_buf)+1; //+1 for _rangeEndList[-1] safe
     self->_rangeEndList[-1]=0;