react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/private_diff/bytes_rle.cpp

@@ -2,7 +2,7 @@
 //
 /*
  The MIT License (MIT)
- Copyright (c) 2012-2021 HouSisong
+ Copyright (c) 2012-2017 HouSisong
 
  Permission is hereby granted, free of charge, to any person
  obtaining a copy of this software and associated documentation
@@ -33,18 +33,13 @@
 namespace hdiff_private{
 
 namespace {
-    const size_t kStepSize=1024*16;
     
     typedef unsigned char TByte;
-    typedef hpatch_StreamPos_t TUInt;
+    typedef size_t TUInt;
 
     static void rle_pushSame(std::vector<TByte>& out_ctrl,std::vector<TByte>& out_code,
                              TByte cur,TUInt count){
         assert(count>0);
-        while (count>kMaxBytesRleLen){
-            rle_pushSame(out_ctrl,out_code,cur,kMaxBytesRleLen);
-            count-=kMaxBytesRleLen;
-        }
         enum TByteRleType type;
         if (cur==0)
             type=kByteRleType_rle0;
@@ -58,96 +53,60 @@ namespace {
             out_code.push_back(cur);
     }
 
-    static inline void rle_pushNotSameCtrl(std::vector<TByte>& out_ctrl,TUInt count){
-        packUIntWithTag(out_ctrl,(TUInt)(count-1),kByteRleType_unrle,kByteRleType_bit);
+    static void rle_pushNotSame(std::vector<TByte>& out_ctrl,std::vector<TByte>& out_code,
+                                const TByte* byteStream,TUInt count){
+        assert(count>0);
+        if (count==1){
+            rle_pushSame(out_ctrl,out_code,(*byteStream),1);
+            return;
+        }
+
+        packUIntWithTag(out_ctrl,(TUInt)(count-1), kByteRleType_unrle,kByteRleType_bit);
+        out_code.insert(out_code.end(),byteStream,byteStream+count);
     }
 
-    struct TStreamRLE{
-        std::vector<unsigned char>&  ctrlBuf;
-        std::vector<unsigned char>&  codeBuf;
-        TByte       sameCur;
-        size_t      sameCount;
-        size_t      notSameCount;
-        const size_t kRleMinSameSize;
-        inline explicit TStreamRLE(std::vector<unsigned char>& _ctrlBuf,
-                                   std::vector<unsigned char>& _codeBuf,int rle_parameter)
-        :ctrlBuf(_ctrlBuf),codeBuf(_codeBuf),sameCur(0),
-        sameCount(0),notSameCount(0),kRleMinSameSize(rle_parameter+1){
-            assert((rle_parameter>=kRle_bestSize)&&(rle_parameter<=kRle_bestUnRleSpeed)); }
-        void append(const unsigned char* appendData,const unsigned char* appendData_end){
-            if (sameCount==0){
-                if (appendData!=appendData_end){
-                    sameCur=*appendData++;
-                    sameCount=1;
-                }else{
-                    return;
-                }
-            }
-            while (appendData!=appendData_end){
-                TByte cur=*appendData++;
-                if (cur==sameCur){
-                    ++sameCount;
-                }else{
-                    endSame();
-                    sameCur=cur;
-                    sameCount=1;
-                }
-            }
-        }
-        inline void endSame(){
-            size_t sign=((size_t)(253-(size_t)(TByte)(sameCur-1))) >> (sizeof(size_t)*8-1);
-            if (sameCount+sign>kRleMinSameSize){//can rle
-                endNoSame();
-                rle_pushSame(ctrlBuf,codeBuf,sameCur,sameCount);
-                sameCount=0;
-            }else{
-                notSameCount+=sameCount;
-                while (sameCount--)
-                    codeBuf.push_back(sameCur);
-            }
+    inline static const TByte* rle_getEqualEnd(const TByte* cur,const TByte* src_end,TByte value){
+        while (cur!=src_end) {
+            if (*cur==value)
+                ++cur;
+            else
+                return cur;
         }
-        inline void endNoSame(){
-            if (notSameCount>1){
-                rle_pushNotSameCtrl(ctrlBuf,notSameCount);
-                notSameCount=0;
-            }else if (notSameCount==1){
-                notSameCount=0;
-                TByte cur=codeBuf.back();
-                codeBuf.pop_back();
-                rle_pushSame(ctrlBuf,codeBuf,cur,1);
-            }
-        }
-        inline void finishAppend(){
-            endSame();
-            endNoSame();
-        }
-    };
+        return src_end;
+    }
     
 }//end namespace
     
-void bytesRLE_save(std::vector<TByte>& out_ctrlBuf,std::vector<TByte>& out_codeBuf,
-                    const TByte* src,const TByte* src_end,int rle_parameter){
-    TStreamRLE rle(out_ctrlBuf,out_codeBuf,rle_parameter);
-    rle.append(src,src_end);
-    rle.finishAppend();
-}
+    void bytesRLE_save(std::vector<TByte>& out_ctrlBuf,std::vector<TByte>& out_codeBuf,
+                       const TByte* src,const TByte* src_end,int rle_parameter){
+        assert(rle_parameter>=kRle_bestSize);
+        assert(rle_parameter<=kRle_bestUnRleSpeed);
+        const TUInt kRleMinSameSize=rle_parameter+1;//增大则压缩率变小,解压稍快.
+
+        const TByte* notSame=src;
+        while (src!=src_end) {
+            //find equal length
+            TByte value=*src;
+            const TByte* eqEnd=rle_getEqualEnd(src+1,src_end,value);
+            const TUInt sameCount=(TUInt)(eqEnd-src);
+            if ( (sameCount>kRleMinSameSize) || (  (sameCount==kRleMinSameSize)
+                                                 &&( (value==0)||(value==255) ) ) ){//可以压缩.
+                if (notSame!=src){
+                    rle_pushNotSame(out_ctrlBuf,out_codeBuf,notSame,(TUInt)(src-notSame));
+                }
+                rle_pushSame(out_ctrlBuf,out_codeBuf,value, sameCount);
 
-void bytesRLE_save(std::vector<unsigned char>& out_ctrlBuf,std::vector<unsigned char>& out_codeBuf,
-                   const hpatch_TStreamInput* src,int rle_parameter){
-    TStreamRLE rle(out_ctrlBuf,out_codeBuf,rle_parameter);
-    TByte buf[kStepSize];
-    hpatch_StreamPos_t readPos=0;
-    while (readPos<src->streamSize){
-        size_t len=kStepSize;
-        if (len+readPos>src->streamSize)
-            len=(size_t)(src->streamSize-readPos);
-        if (!src->read(src,readPos,buf,buf+len))
-            throw std::runtime_error("bytesRLE_save() src->read()");
-        rle.append(buf,buf+len);
-        readPos+=len;
+                src+=sameCount;
+                notSame=src;
+            }else{
+                src=eqEnd;
+            }
+        }
+        if (notSame!=src_end){
+            rle_pushNotSame(out_ctrlBuf,out_codeBuf,notSame,(TUInt)(src_end-notSame));
+        }
     }
-    rle.finishAppend();
-}
+
 
 void bytesRLE_save(std::vector<TByte>& out_code,
                    const TByte* src,const TByte* src_end,int rle_parameter){
@@ -160,221 +119,92 @@ void bytesRLE_save(std::vector<TByte>& out_code,
     pushBack(out_code,codeBuf);
 }
 
-void bytesRLE_save(std::vector<TByte>& out_code,const hpatch_TStreamInput* src,int rle_parameter){
-    std::vector<TByte> ctrlBuf;
-    std::vector<TByte> codeBuf;
-
-    bytesRLE_save(ctrlBuf,codeBuf,src,rle_parameter);
-    packUInt(out_code,(TUInt)ctrlBuf.size());
-    pushBack(out_code,ctrlBuf);
-    pushBack(out_code,codeBuf);
-}
-
     
     enum TLastType{
-        lastType_same,
+        lastType_0,
         lastType_v,
     };
     
-    inline TLastType getLastType(const TSingleStreamRLE0& self){
-        if (self.uncompressData.empty()){
-            return lastType_same;
-        }else{
+    inline TLastType getLastType(const TSangileStreamRLE0& self){
+        if (!self.uncompressData.empty()){
             assert(self.len0==0);
             return lastType_v;
+        }else{
+            return lastType_0;
         }
     }
     
-    inline void _out_uncompressData(TSingleStreamRLE0& self){
-        size_t saved=0;
-        while (self.uncompressData.size()-saved>kMaxBytesRleLen){
-            packUInt(self.fixed_code, kMaxBytesRleLen);
-            pushBack(self.fixed_code, self.uncompressData.data()+saved,self.uncompressData.data()+saved+kMaxBytesRleLen);
-            packUInt(self.fixed_code,0);
-            saved+=kMaxBytesRleLen;
-        }
-        packUInt(self.fixed_code, self.uncompressData.size()-saved);
-        pushBack(self.fixed_code, self.uncompressData.data()+saved,self.uncompressData.data()+self.uncompressData.size());
-        self.uncompressData.clear();
-    }
-    inline hpatch_StreamPos_t _out_uncompressData_codeSize(hpatch_StreamPos_t dataSize){
-        hpatch_StreamPos_t codeSize=0;
-        hpatch_StreamPos_t saved=0;
-        while (dataSize-saved>kMaxBytesRleLen){
-            codeSize+=hpatch_packUInt_size(kMaxBytesRleLen);
-            codeSize+=kMaxBytesRleLen;
-            codeSize+=hpatch_packUInt_size(0);
-            saved+=kMaxBytesRleLen;
-        }
-        codeSize+=hpatch_packUInt_size(dataSize-saved);
-        codeSize+=(hpatch_StreamPos_t)(dataSize-saved);
-        return codeSize;
-    }
-
-    inline void _out_0Data(TSingleStreamRLE0& self){
-        hpatch_StreamPos_t saved=0;
-        while (self.len0-saved>kMaxBytesRleLen){
-            packUInt(self.fixed_code,kMaxBytesRleLen);
-            packUInt(self.fixed_code,0);
-            saved+=kMaxBytesRleLen;
-        }
-        packUInt(self.fixed_code,(hpatch_StreamPos_t)(self.len0-saved));
-        self.len0=0;
-    }
-    inline hpatch_StreamPos_t _out_0Data_codeSize(hpatch_StreamPos_t len0){
-        hpatch_StreamPos_t codeSize=0;
-        hpatch_StreamPos_t saved=0;
-        while (len0-saved>kMaxBytesRleLen){
-            codeSize+=hpatch_packUInt_size(kMaxBytesRleLen);
-            codeSize+=hpatch_packUInt_size(0);
-            saved+=kMaxBytesRleLen;
-        }
-        codeSize+=hpatch_packUInt_size((hpatch_StreamPos_t)(len0-saved));
-        return codeSize;
-    }
-
-
-    static void _maxCodeSize(TLastType& lastType,hpatch_StreamPos_t& curLen0,hpatch_StreamPos_t& curLenv,
-                             hpatch_StreamPos_t& fixedLen,const unsigned char* appendData,const unsigned char* appendData_end){
+    size_t TSangileStreamRLE0::maxCodeSize(const unsigned char* appendData,const unsigned char* appendData_end) const{
+        TLastType lastType=getLastType(*this);
+        size_t curLen0=this->len0;
+        size_t curLenv=this->uncompressData.size();
+        size_t fixedLen=this->fixed_code.size();
         while (appendData!=appendData_end) {
-            unsigned char v;
-            size_t sLen0=0;
-            do {
-                v=*appendData++;
-                if (0==v)
-                    ++sLen0;
-                else
-                    break;
-            }while (appendData!=appendData_end);
-            if (sLen0>0){
+            if (*appendData==0){
                 if (lastType==lastType_v){
-                    fixedLen += _out_uncompressData_codeSize(curLenv);
+                    fixedLen += hpatch_packUInt_size(curLenv) + curLenv;
                     curLenv = 0;
                 }
-                curLen0+=sLen0;
-                lastType=lastType_same;
-                if (v==0)
-                    break;//appendData==appendData_end
-            }
-            if (lastType==lastType_same){
-                fixedLen += _out_0Data_codeSize(curLen0);
-                curLen0 = 0;
+                ++curLen0;
+                lastType=lastType_0;
+            }else{
+                if (lastType==lastType_0){
+                    fixedLen += hpatch_packUInt_size(curLen0);
+                    curLen0 = 0;
+                }
+                ++curLenv;
+                lastType=lastType_v;
             }
-            ++curLenv;
-            lastType=lastType_v;
-        }
-    }
-    static void _maxCodeSize_end(TLastType& lastType,hpatch_StreamPos_t& curLen0,
-                                 hpatch_StreamPos_t& curLenv,hpatch_StreamPos_t& fixedLen){
-        if (curLenv>0){
-            fixedLen += _out_uncompressData_codeSize(curLenv);
-            curLenv=0;
-        }
-        if (curLen0>0){
-            fixedLen += _out_0Data_codeSize(curLen0);
-            curLen0=0;
+            ++appendData;
         }
-    }
-    
-    hpatch_StreamPos_t TSingleStreamRLE0::maxCodeSize(const unsigned char* appendData,const unsigned char* appendData_end) const{
-        TLastType lastType=getLastType(*this);
-        hpatch_StreamPos_t curLen0=this->len0;
-        hpatch_StreamPos_t curLenv=this->uncompressData.size();
-        hpatch_StreamPos_t fixedLen=this->fixed_code.size();
-        _maxCodeSize(lastType,curLen0,curLenv,fixedLen,appendData,appendData_end);
-        _maxCodeSize_end(lastType,curLen0,curLenv,fixedLen);
+        if (curLenv>0)
+            fixedLen += hpatch_packUInt_size(curLenv) + curLenv;
+        if (curLen0>0)
+            fixedLen += hpatch_packUInt_size(curLen0);
         return fixedLen;
     }
     
-    hpatch_StreamPos_t TSingleStreamRLE0::maxCodeSizeByZeroLen(hpatch_StreamPos_t appendZeroLen) const{
-        hpatch_StreamPos_t fixedLen=this->fixed_code.size();
-        if (appendZeroLen==0) return fixedLen;
-        TLastType lastType=getLastType(*this);
-        hpatch_StreamPos_t curLen0=this->len0;
-        hpatch_StreamPos_t curLenv=this->uncompressData.size();
-        curLen0+=appendZeroLen;
-        if (lastType==lastType_v){
-            fixedLen += _out_uncompressData_codeSize(curLenv);
-            curLenv = 0;
+    inline void _out_uncompressData(TSangileStreamRLE0& self){
+        size_t saved=0;
+        while (self.uncompressData.size()-saved>kMaxBytesRle0Len){
+            packUInt(self.fixed_code, kMaxBytesRle0Len);
+            pushBack(self.fixed_code, self.uncompressData.data()+saved,self.uncompressData.data()+saved+kMaxBytesRle0Len);
+            packUInt(self.fixed_code,0);
+            saved+=kMaxBytesRle0Len;
         }
-        lastType=lastType_same;
-        _maxCodeSize_end(lastType,curLen0,curLenv,fixedLen);
-        return fixedLen;
+        packUInt(self.fixed_code, self.uncompressData.size()-saved);
+        pushBack(self.fixed_code, self.uncompressData.data()+saved,self.uncompressData.data()+self.uncompressData.size());
+        self.uncompressData.clear();
     }
-
-    hpatch_StreamPos_t TSingleStreamRLE0::maxCodeSize(const hpatch_TStreamInput* appendData) const{
-        TLastType lastType=getLastType(*this);
-        hpatch_StreamPos_t curLen0=this->len0;
-        hpatch_StreamPos_t curLenv=this->uncompressData.size();
-        hpatch_StreamPos_t fixedLen=this->fixed_code.size();
-        
-        TByte buf[kStepSize];
-        hpatch_StreamPos_t readPos=0;
-        while (readPos<appendData->streamSize){
-            size_t len=kStepSize;
-            if (len+readPos>appendData->streamSize)
-                len=(size_t)(appendData->streamSize-readPos);
-            if (!appendData->read(appendData,readPos,buf,buf+len))
-                throw std::runtime_error("TSingleStreamRLE0::maxCodeSize() appendData->read()");
-            _maxCodeSize(lastType,curLen0,curLenv,fixedLen,buf,buf+len);
-            readPos+=len;
+    inline void _out_0Data(TSangileStreamRLE0& self){
+        while (self.len0>kMaxBytesRle0Len){
+            packUInt(self.fixed_code,kMaxBytesRle0Len);
+            self.len0-=kMaxBytesRle0Len;
+            packUInt(self.fixed_code,0);
         }
-        _maxCodeSize_end(lastType,curLen0,curLenv,fixedLen);
-        return fixedLen;
+        packUInt(self.fixed_code, self.len0);
+        self.len0=0;
     }
     
-    
-    void TSingleStreamRLE0::appendByZeroLen(hpatch_StreamPos_t appendZeroLen){
-        if (appendZeroLen){
-            TLastType lastType=getLastType(*this);
-            if (lastType==lastType_v)
-                _out_uncompressData(*this);
-            len0+=appendZeroLen;
-        }
-    }
-
-    void TSingleStreamRLE0::append(const unsigned char* appendData,const unsigned char* appendData_end){
+    void TSangileStreamRLE0::append(const unsigned char* appendData,const unsigned char* appendData_end){
         TLastType lastType=getLastType(*this);
         while (appendData!=appendData_end) {
-            unsigned char v;
-            size_t sLen0=0;
-            do {
-                v=*appendData++;
-                if (0==v)
-                    ++sLen0;
-                else
-                    break;
-            }while (appendData!=appendData_end);
-            if (sLen0>0){
+            if (*appendData==0){
                 if (lastType==lastType_v)
                     _out_uncompressData(*this);
-                len0+=sLen0;
-                lastType=lastType_same;
-                if (v==0)
-                    break;//appendData==appendData_end
+                ++len0;
+                lastType=lastType_0;
+            }else{
+                if (lastType==lastType_0)
+                    _out_0Data(*this);
+                uncompressData.push_back(*appendData);
+                lastType=lastType_v;
             }
-            if (lastType==lastType_same)
-                _out_0Data(*this);
-            uncompressData.push_back(v);
-            lastType=lastType_v;
-        }
-    }
-    
-    void TSingleStreamRLE0::append(const hpatch_TStreamInput* appendData){
-        TByte buf[kStepSize];
-        hpatch_StreamPos_t readPos=0;
-        while (readPos<appendData->streamSize){
-            size_t len=kStepSize;
-            if (len+readPos>appendData->streamSize)
-                len=(size_t)(appendData->streamSize-readPos);
-            if (!appendData->read(appendData,readPos,buf,buf+len))
-                throw std::runtime_error("TSingleStreamRLE0::append() appendData->read()");
-            append(buf,buf+len);
-            readPos+=len;
+            ++appendData;
         }
     }
     
-    void TSingleStreamRLE0::finishAppend(){
+    void TSangileStreamRLE0::finishAppend(){
         if ((fixed_code.empty())||(len0>0))
             _out_0Data(*this);
         if (!uncompressData.empty())

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/private_diff/bytes_rle.h

@@ -1,9 +1,9 @@
 //bytes_rle.h
-//a general-purpose byte stream compression RLE algorithm optimized for fast decompression.
+//快速解压的一个通用字节流压缩rle算法.
 //
 /*
  The MIT License (MIT)
- Copyright (c) 2012-2021 HouSisong
+ Copyright (c) 2012-2017 HouSisong
  
  Permission is hereby granted, free of charge, to any person
  obtaining a copy of this software and associated documentation
@@ -31,40 +31,30 @@
 #define __BYTES_RLE_H_
 #include <string.h>
 #include <vector>
-#include "../../HPatch/patch_types.h" //hpatch_TStreamInput
 namespace hdiff_private{
 
-#ifndef kMaxBytesRleLen
-    static const size_t kMaxBytesRleLen =(size_t)(((size_t)1<<31)-1);
-#endif
-
 enum TRleParameter{ kRle_bestSize=1, kRle_default=3, kRle_bestUnRleSpeed=32 };
 
 void bytesRLE_save(std::vector<unsigned char>& out_code,
                    const unsigned char* src,const unsigned char* src_end,
                    int rle_parameter=kRle_default);
-void bytesRLE_save(std::vector<unsigned char>& out_code,
-                   const hpatch_TStreamInput* src,//sequential read
-                   int rle_parameter=kRle_default);
+
 
 void bytesRLE_save(std::vector<unsigned char>& out_ctrlBuf,std::vector<unsigned char>& out_codeBuf,
                    const unsigned char* src,const unsigned char* src_end,int rle_parameter);
-void bytesRLE_save(std::vector<unsigned char>& out_ctrlBuf,std::vector<unsigned char>& out_codeBuf,
-                   const hpatch_TStreamInput* src,//sequential read
-                   int rle_parameter);
+
+#ifndef kMaxBytesRle0Len
+    static const size_t kMaxBytesRle0Len =(size_t)(((size_t)1<<31)-1);
+#endif
     
-    struct TSingleStreamRLE0{
+    struct TSangileStreamRLE0{
         std::vector<unsigned char>  fixed_code;
         std::vector<unsigned char>  uncompressData;
-        hpatch_StreamPos_t          len0;
-        inline TSingleStreamRLE0():len0(0){}
-        inline hpatch_StreamPos_t curCodeSize() const { return maxCodeSize(0,0); }
-        hpatch_StreamPos_t maxCodeSize(const unsigned char* appendData,const unsigned char* appendData_end) const;
-        hpatch_StreamPos_t maxCodeSize(const hpatch_TStreamInput* appendData) const;//sequential read
-        hpatch_StreamPos_t maxCodeSizeByZeroLen(hpatch_StreamPos_t appendZeroLen) const;
+        size_t                      len0;
+        inline TSangileStreamRLE0():len0(0){}
+        inline size_t curCodeSize() const { return maxCodeSize(0,0); }
+        size_t maxCodeSize(const unsigned char* appendData,const unsigned char* appendData_end) const;
         void append(const unsigned char* appendData,const unsigned char* appendData_end);
-        void append(const hpatch_TStreamInput* appendData);//sequential read
-        void appendByZeroLen(hpatch_StreamPos_t appendZeroLen);
         void finishAppend();
         inline void clear() { fixed_code.clear(); uncompressData.clear(); len0=0; }
     };

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/private_diff/compress_detect.cpp

@@ -74,19 +74,12 @@ size_t getRegionRleCost(const unsigned char* d,size_t n,const unsigned char* sub
 }
 
 static const size_t kCacheSize=(1<<19);
-TCompressDetect::TCompressDetect():m_table(0){
+TCompressDetect::TCompressDetect()
+:m_table(0),m_lastChar(-1),
+m_lastPopChar(-1),m_cacheBegin(0),m_cacheEnd(0){
     m_mem.realloc(sizeof(TCharConvTable)+kCacheSize);
     m_table=(TCharConvTable*)m_mem.data();
-    m_lastChar=0; //for clear TCharConvTable
-    clear();
-}
-void TCompressDetect::clear(){
-    if (m_lastChar>=0)
-        memset(m_table,0,sizeof(TCharConvTable));
-    m_lastChar=-1;
-    m_lastPopChar=-1;
-    m_cacheBegin=0;
-    m_cacheEnd=0;
+    memset(m_table,0,sizeof(TCharConvTable));
 }
 TCompressDetect::~TCompressDetect(){
 }
@@ -165,13 +158,6 @@ static const size_t _kBufSize=1024;
 
 
 void TCompressDetect::add_chars(const unsigned char* d,size_t n,const unsigned char* sub){
-    if (n>kCacheSize+sizeof(TCharConvTable)){
-        clear();
-        size_t skip_n=n-kCacheSize;
-        n=kCacheSize;
-        d+=skip_n;
-        if (sub) sub+=skip_n;
-    }
     by_step(this->_add_rle);
 }
 

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/private_diff/compress_detect.h

@@ -1,5 +1,5 @@
 //compress_detect.h
-// Roughly estimate data compressibility for diff.
+//粗略估算数据的可压缩性 for diff.
 /*
  The MIT License (MIT)
  Copyright (c) 2012-2017 HouSisong
@@ -25,9 +25,8 @@
  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  OTHER DEALINGS IN THE SOFTWARE.
 */
-#ifdef _MSC_VER
+
 #pragma warning( disable : 4706)
-#endif
 
 #ifndef compress_detect_h
 #define compress_detect_h
@@ -55,7 +54,7 @@ inline static unsigned _getIntCost(_Int v){
     return _getUIntCost((_UInt)(2*((v>=0)?(_UInt)v:(_UInt)(-v))));
 }
 
-// Roughly estimate storage cost for this region.
+//粗略估算该区域存储成本.
 size_t getRegionRleCost(const unsigned char* d,size_t n,const unsigned char* sub=0,
                         unsigned char* out_nocompress=0,size_t* nocompressSize=0);
 
@@ -69,8 +68,8 @@ private:
     struct TCharConvTable{
         hpatch_uint32_t sum;
         hpatch_uint32_t sum1char[256];
-        hpatch_uint32_t sum2char[256*256];// Use adjacent character transition probability to approximately estimate data compressibility.
-        unsigned char cache[1];// Actual size is kCacheSize, old data beyond this distance will be cleared.
+        hpatch_uint32_t sum2char[256*256];//用相邻字符转换几率来近似估计数据的可压缩性.
+        unsigned char cache[1];//实际大小为kCacheSize,超出该距离的旧数据会被清除.
     };
     TAutoMem        m_mem;
     TCharConvTable* m_table;
@@ -78,7 +77,6 @@ private:
     int             m_lastPopChar;
     hpatch_uint32_t m_cacheBegin;
     hpatch_uint32_t m_cacheEnd;
-    void clear();
     void _add_rle(const unsigned char* d,size_t n);
     size_t _cost_rle(const unsigned char* d,size_t n)const;
 };

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/private_diff/libdivsufsort/{divsufsort.cpp → divsufsort.c}

@@ -1,10 +1,13 @@
+#ifdef BUILD_DIVSUFSORT64
+#  undef BUILD_DIVSUFSORT64
+#endif
 #define HAVE_CONFIG_H 1
-# include "divsufsort.h"
-typedef saidx32_t saidx_t;
-typedef saidx_t sastore_t;
-
+#include <stdio.h>
 #include "divsufsort_private.h"
+
 #include "divsufsort.c.inc.h"
-#include "sssort.c.inc.h"
 #include "trsort.c.inc.h"
+#define lg_table sssort_lg_table
+#include "sssort.c.inc.h"
+#include "utils.c.inc.h"