react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HPatchLite/hpatch_lite.c

@@ -1,366 +0,0 @@
-//hpatch_lite.c
-//
-/*
- The MIT License (MIT)
- Copyright (c) 2020-2022 HouSisong All Rights Reserved.
-*/
-#include "hpatch_lite.h"
-#include "hpatch_lite_input_cache.h"
-
-#define _hpi_FALSE  hpi_FALSE
-//hpi_size_t __debug_check_false_x=0; //for debug
-//#define _hpi_FALSE (1/__debug_check_false_x)
-
-#if (_IS_RUN_MEM_SAFE_CHECK)
-#   define __RUN_MEM_SAFE_CHECK
-#endif
-
-#define _CHECK(code)                { if (!(code)) return _hpi_FALSE; }
-
-#ifdef __RUN_MEM_SAFE_CHECK
-#   define  _SAFE_CHECK(checkv)     _CHECK(checkv)
-#else
-#   define  _SAFE_CHECK(checkv)
-#endif
-
-#define _TInputCache            _hpi_TInputCache
-#define _cache_read_1byte       _hpi_cache_read_1byte
-#define _cache_update           _hpi_cache_update
-#define _cache_success_finish   _hpi_cache_success_finish
-
-hpi_BOOL _cache_update(struct _TInputCache* self){
-    //    [                    cache  buf                        ]
-    hpi_size_t len=self->cache_end;
-    assert(len==self->cache_begin); //empty
-    if (!self->read_code(self->inputStream,self->cache_buf,&len))
-        len=0;
-    //    |                                   len|               |
-    self->cache_begin=0;
-    self->cache_end=len;
-    return len!=0;
-}
-
-hpi_fast_uint8 _cache_read_1byte(struct _TInputCache* self){
-    if (self->cache_begin!=self->cache_end){
-__cache_read_1byte:
-        return self->cache_buf[self->cache_begin++];
-    }
-    if(_cache_update(self))
-        goto __cache_read_1byte;
-    else
-        return 0;
-}
-
-static hpi_pos_t _cache_unpackUInt(_TInputCache* self,hpi_pos_t v,hpi_fast_uint8 isNext){
-    while (isNext){
-        hpi_fast_uint8 b=_cache_read_1byte(self);
-        v=(v<<7)|(b&127);
-        isNext=b>>7;
-    }
-    return v;
-}
-
-static hpi_BOOL _patch_copy_diff(hpatchi_listener_t* out_newData,
-                                 _TInputCache* diff,hpi_pos_t copyLength){
-    while (copyLength>0){
-        hpi_size_t decodeStep=diff->cache_end-diff->cache_begin;
-        if (decodeStep==0){
-            _CHECK(_cache_update(diff));
-            decodeStep=diff->cache_end-diff->cache_begin;
-        }
-        if (decodeStep>copyLength)
-            decodeStep=(hpi_size_t)copyLength;
-        _CHECK(out_newData->write_new(out_newData,diff->cache_buf+diff->cache_begin,decodeStep));
-        diff->cache_begin+=decodeStep;
-        copyLength-=(hpi_pos_t)decodeStep;
-    }
-    return hpi_TRUE;
-}
-
-    static hpi_force_inline void addData(hpi_byte* dst,const hpi_byte* src,hpi_size_t length){
-        while (length--) { *dst++ += *src++; } }
-static hpi_BOOL _patch_add_old_withClip(hpatchi_listener_t* old_and_new,_TInputCache* diff,hpi_BOOL isNotNeedSubDiff,
-                                        hpi_size_t oldPos,hpi_size_t addLength,hpi_byte* temp_cache){
-    while (addLength>0){
-        hpi_size_t decodeStep=diff->cache_end;
-        if (!isNotNeedSubDiff){
-            decodeStep-=diff->cache_begin;
-            if (decodeStep==0){
-                _cache_update(diff);
-                decodeStep=diff->cache_end-diff->cache_begin;
-            }
-        }
-        _CHECK(decodeStep>0);
-        if (decodeStep>addLength)
-            decodeStep=(hpi_size_t)addLength;
-        _CHECK(old_and_new->read_old(old_and_new,oldPos,temp_cache,(hpi_pos_t)decodeStep));
-        if (!isNotNeedSubDiff){
-            addData(temp_cache,diff->cache_buf+diff->cache_begin,decodeStep);
-            diff->cache_begin+=decodeStep;
-        }
-        _CHECK(old_and_new->write_new(old_and_new,temp_cache,decodeStep));
-        oldPos+=decodeStep;
-        addLength-=decodeStep;
-    }
-    return hpi_TRUE;
-}
-
-static hpi_pos_t _hpi_readSize(const hpi_byte* buf,hpi_size_t len){
-    hpi_pos_t v=0;
-    while(len--){
-        v=(v<<8)|(hpi_pos_t)buf[len];
-    }
-    return v;
-}
-
-hpi_BOOL hpatch_lite_open(hpi_TInputStreamHandle diff_data,hpi_TInputStream_read read_diff,
-                          hpi_compressType* out_compress_type,hpi_pos_t* out_newSize,hpi_pos_t* out_uncompressSize){
-    #define kHPatchLite_versionCode     1
-    hpi_size_t lenn=hpi_kHeadSize;
-    hpi_size_t lenu;
-    hpi_byte   buf[(hpi_kHeadSize>sizeof(hpi_pos_t))?hpi_kHeadSize:sizeof(hpi_pos_t)];
-    
-    _CHECK(read_diff(diff_data,buf,&lenn));
-    //HPatchLite type tag 2byte, version code(high 2bit)
-    lenu=buf[3];
-    _SAFE_CHECK((lenn==hpi_kHeadSize)&(buf[0]=='h')&(buf[1]=='I')&((lenu>>6)==kHPatchLite_versionCode));
-    *out_compress_type=buf[2]; //compress type
-    lenn=lenu&7; //newSize bytes(low 3bit)
-    lenu=(lenu>>3)&7; //uncompressSize bytes(mid 3bit)
-
-    _SAFE_CHECK((lenn<=sizeof(hpi_pos_t))&(lenu<=sizeof(hpi_pos_t)));
-    _CHECK(read_diff(diff_data,buf,&lenn));
-    *out_newSize=_hpi_readSize(buf,lenn);
-    _CHECK(read_diff(diff_data,buf,&lenu));
-    *out_uncompressSize=_hpi_readSize(buf,lenu);
-    return hpi_TRUE;
-}
-
-hpi_BOOL hpatch_lite_patch(hpatchi_listener_t* listener,hpi_pos_t newSize,
-                           hpi_byte* temp_cache,hpi_size_t temp_cache_size){
-    _TInputCache  diff;
-    hpi_pos_t  coverCount;
-    hpi_pos_t  newPosBack=0;
-    hpi_pos_t  oldPosBack=0;
-    {
-        assert(temp_cache);
-        _SAFE_CHECK(temp_cache_size>=hpi_kMinCacheSize);
-        temp_cache_size>>=1;
-        diff.cache_begin=temp_cache_size;
-        diff.cache_end=temp_cache_size;
-        diff.cache_buf=temp_cache+temp_cache_size;
-        diff.inputStream=listener->diff_data;
-        diff.read_code=listener->read_diff;
-    }
-    coverCount=_cache_unpackUInt(&diff,0,hpi_TRUE);
-
-    while (coverCount--){
-        hpi_pos_t cover_oldPos;
-        hpi_pos_t cover_newPos;
-        hpi_pos_t cover_length;
-        hpi_BOOL  isNotNeedSubDiff;
-        {//read cover
-            cover_length=_cache_unpackUInt(&diff,0,hpi_TRUE);
-            {
-                hpi_fast_uint8 tag=_cache_read_1byte(&diff);
-                cover_oldPos=_cache_unpackUInt(&diff,tag&31,tag&(1<<5));
-                isNotNeedSubDiff=(tag>>7);
-                if (tag&(1<<6))
-                    cover_oldPos=oldPosBack-cover_oldPos;
-                else
-                    cover_oldPos+=oldPosBack;
-            }
-            cover_newPos=_cache_unpackUInt(&diff,0,hpi_TRUE);
-            cover_newPos+=newPosBack;
-        }
-
-        _SAFE_CHECK(cover_newPos>=newPosBack);
-        if (newPosBack<cover_newPos)
-            _CHECK(_patch_copy_diff(listener,&diff,cover_newPos-newPosBack));
-        _CHECK(_patch_add_old_withClip(listener,&diff,isNotNeedSubDiff,cover_oldPos,cover_length,temp_cache));
-        newPosBack=cover_newPos+cover_length;
-        oldPosBack=cover_oldPos+cover_length;
-        _SAFE_CHECK((cover_length>0)|(coverCount==0));
-    }
-    return (newSize==newPosBack)&_cache_success_finish(&diff);
-}
-
-
-
-// inplace hpatchi by extra
-
-hpi_BOOL hpatchi_inplace_open(hpi_TInputStreamHandle diff_data,hpi_TInputStream_read read_diff,
-                              hpi_compressType* out_compress_type,hpi_pos_t* out_newSize,
-                              hpi_pos_t* out_uncompressSize,hpi_size_t* out_extraSafeSize){
-    #define kHPatchLite_inplaceCode     2
-    hpi_size_t lenn=hpi_kInplaceHeadSize;
-    hpi_size_t lenu,lene;
-    hpi_byte   buf[(hpi_kInplaceHeadSize>sizeof(hpi_pos_t))?hpi_kInplaceHeadSize:sizeof(hpi_pos_t)];
-    
-    _CHECK(read_diff(diff_data,buf,&lenn));
-    //HPatchLite type tag 2byte, version code(high 2bit)
-    lenu=buf[3];
-    _SAFE_CHECK((lenn==hpi_kInplaceHeadSize)&(buf[0]=='h')&(buf[1]=='I')&((lenu>>6)==kHPatchLite_inplaceCode));
-    *out_compress_type=buf[2]; //compress type
-    lenn=lenu&7; //newSize bytes(low 3bit)
-    lenu=(lenu>>3)&7; //uncompressSize bytes(mid 3bit)
-    lene=buf[4];
-
-    _SAFE_CHECK((lenn<=sizeof(hpi_pos_t))&(lenu<=sizeof(hpi_pos_t))&(lene<=sizeof(hpi_size_t)));
-    _CHECK(read_diff(diff_data,buf,&lenn));
-    *out_newSize=_hpi_readSize(buf,lenn);
-    _CHECK(read_diff(diff_data,buf,&lenu));
-    *out_uncompressSize=_hpi_readSize(buf,lenu);
-    _CHECK(read_diff(diff_data,buf,&lene));
-    *out_extraSafeSize=(hpi_size_t)_hpi_readSize(buf,lene);
-    return hpi_TRUE;
-}
-
-
-
-#if (_IS_WTITE_NEW_BY_PAGE!=0)
-#   define _hpi_Do4Page(code)   do{ code; }while(0)
-#else
-#   define _hpi_Do4Page(code)
-#endif //_IS_WTITE_NEW_BY_PAGE
-
-//hpatchi_listener_extra_t: a first-in-first-out ring buffer
-//  always cache kWriteExtraSize bytes latest data for _wrap_listener->write_new;
-typedef struct hpatchi_listener_extra_t{
-    hpatchi_listener_t      base;
-    hpatchi_listener_t*     _wrap_listener;
-    hpi_byte*  write_extra;
-    hpi_size_t kWriteExtraSize;
-    hpi_size_t cached_data_pos;
-    hpi_size_t cached_data_len;
-    #if (_IS_WTITE_NEW_BY_PAGE!=0)
-    hpi_size_t kPageSize;
-    hpi_size_t page_data_len; //cur page data length
-    #endif
-} hpatchi_listener_extra_t;
-
-static hpi_BOOL _hpatchi_listener_extra_read_old(hpatchi_listener_t* listener,hpi_pos_t read_from_pos,hpi_byte* out_data,hpi_size_t data_size){
-    hpatchi_listener_extra_t* self=(hpatchi_listener_extra_t*)listener;
-    return self->_wrap_listener->read_old(self->_wrap_listener,read_from_pos,out_data,data_size);
-}
-
-#if (_IS_WTITE_NEW_BY_PAGE!=0)
-    static hpi_BOOL _hpatchi_listener_page_out(hpatchi_listener_extra_t* self){
-        hpi_BOOL result=self->_wrap_listener->write_new(self->_wrap_listener,
-                            self->write_extra+self->kWriteExtraSize,self->page_data_len);
-        self->page_data_len=0;
-        return result;
-    }
-
-    static hpi_force_inline
-    hpi_BOOL _hpatchi_listener_write_page(hpatchi_listener_extra_t* self,const hpi_byte* data,hpi_size_t data_size){
-        hpi_byte* page_buf=self->write_extra+self->kWriteExtraSize;
-        while (data_size){
-            hpi_size_t cur_len=self->kPageSize-self->page_data_len;
-            if (cur_len==0){ //need out cur page
-                if (!_hpatchi_listener_page_out(self)) return _hpi_FALSE;
-                cur_len=self->kPageSize;
-            }
-            cur_len=(cur_len<=data_size)?cur_len:data_size;
-            data_size-=cur_len;
-            while (cur_len--)//save data to page
-                page_buf[self->page_data_len++]=*data++;
-        }
-        return hpi_TRUE;
-    }
-#endif //_IS_WTITE_NEW_BY_PAGE
-
-static hpi_BOOL _hpatchi_listener_extra_out(hpatchi_listener_extra_t* self,hpi_size_t out_size){
-    assert(out_size<=self->cached_data_len);
-    while (out_size){
-        hpi_size_t cur_len=self->kWriteExtraSize-self->cached_data_pos;
-        cur_len=(cur_len<=out_size)?cur_len:out_size;
-    #if (_IS_WTITE_NEW_BY_PAGE!=0)
-        if (!_hpatchi_listener_write_page(self,self->write_extra+self->cached_data_pos,cur_len))
-            return _hpi_FALSE;
-    #else
-        if (!self->_wrap_listener->write_new(self->_wrap_listener,self->write_extra+self->cached_data_pos,cur_len))
-            return _hpi_FALSE;
-    #endif //_IS_WTITE_NEW_BY_PAGE
-        self->cached_data_pos+=cur_len;
-        self->cached_data_pos-=(self->cached_data_pos<self->kWriteExtraSize)?0:self->kWriteExtraSize;
-        self->cached_data_len-=cur_len;
-        out_size-=cur_len;
-    }
-    return hpi_TRUE;
-}
-
-static hpi_force_inline
-hpi_BOOL _hpatchi_listener_extra_flush(hpatchi_listener_extra_t* self){
-    hpi_BOOL result=_hpatchi_listener_extra_out(self,self->cached_data_len);
-#if (_IS_WTITE_NEW_BY_PAGE!=0)
-    if (result&&(self->page_data_len))
-        result=_hpatchi_listener_page_out(self);
-#endif //_IS_WTITE_NEW_BY_PAGE
-    return result;
-}
-
-static hpi_BOOL _hpatchi_listener_extra_write_new(hpatchi_listener_t* listener,const hpi_byte* data,hpi_size_t data_size){
-    hpatchi_listener_extra_t* self=(hpatchi_listener_extra_t*)listener;
-    while (data_size){
-        hpi_size_t posi;
-        hpi_size_t cur_len=data_size+self->cached_data_len;
-        if (cur_len>self->kWriteExtraSize){//need out cached data by _wrap_listener->write_new()
-            cur_len-=self->kWriteExtraSize;
-            cur_len=(cur_len<=self->cached_data_len)?cur_len:self->cached_data_len;
-            if (!_hpatchi_listener_extra_out(self,cur_len)) return _hpi_FALSE;
-        }
-        assert(self->cached_data_len<self->kWriteExtraSize);
-
-        cur_len=self->kWriteExtraSize-self->cached_data_len;
-        cur_len=(cur_len<=data_size)?cur_len:data_size;
-        data_size-=cur_len;
-        posi=self->cached_data_pos+self->cached_data_len;
-        self->cached_data_len+=cur_len;
-        while (cur_len--){//save data to cache
-            posi-=(posi<self->kWriteExtraSize)?0:self->kWriteExtraSize;
-            self->write_extra[posi++]=*data++;
-        }
-    }
-    return hpi_TRUE;
-}
-
-static hpi_inline
-void _hpatchi_listener_extra_init(hpatchi_listener_extra_t* self,hpatchi_listener_t* wrap_listener,
-                                  hpi_byte* write_extra,hpi_size_t kWriteExtraSize){
-    self->base.diff_data=wrap_listener->diff_data;
-    self->base.read_diff=wrap_listener->read_diff; 
-    self->base.read_old=_hpatchi_listener_extra_read_old;
-    self->base.write_new=_hpatchi_listener_extra_write_new; 
-    self->_wrap_listener=wrap_listener;
-    self->write_extra=write_extra;
-    self->kWriteExtraSize=kWriteExtraSize;
-    self->cached_data_pos=0;
-    self->cached_data_len=0;
-}
-
-#if (_IS_WTITE_NEW_BY_PAGE!=0)
-hpi_BOOL hpatchi_inplaceB_by_page(hpatchi_listener_t* listener,hpi_pos_t newSize,hpi_byte* temp_cache,
-                                  hpi_size_t extraSafeSize,hpi_size_t pageSize,hpi_size_t temp_cache_size){
-#else //_IS_WTITE_NEW_BY_PAGE==0
-hpi_BOOL hpatchi_inplaceB(hpatchi_listener_t* listener,hpi_pos_t newSize,
-                          hpi_byte* temp_cache,hpi_size_t extraSafeSize,hpi_size_t temp_cache_size){
-    const hpi_size_t pageSize=0;
-#endif //_IS_WTITE_NEW_BY_PAGE
-    hpi_BOOL result;
-    hpatchi_listener_extra_t extra_listener;
-    const hpi_size_t needExtra=extraSafeSize+pageSize;
-    assert(temp_cache_size>=hpi_kMinInplaceCacheSize+extraSafeSize+pageSize);
-    _hpi_Do4Page(assert(pageSize>0));
-    if (needExtra){
-        hpi_size_t cache_size=(temp_cache_size-needExtra)>>1;
-        extraSafeSize=(extraSafeSize>=cache_size)?extraSafeSize:cache_size;//for small extraSafeSize
-    }
-    _hpatchi_listener_extra_init(&extra_listener,listener,temp_cache,extraSafeSize);
-    _hpi_Do4Page(extra_listener.kPageSize=pageSize);
-    _hpi_Do4Page(extra_listener.page_data_len=0);
-    _hpi_Do4Page(extraSafeSize+=pageSize);//page buf for page data
-    result=hpatch_lite_patch(needExtra?&extra_listener.base:listener,newSize,
-                             temp_cache+extraSafeSize,temp_cache_size-extraSafeSize);
-    return result&&_hpatchi_listener_extra_flush(&extra_listener);
-}

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HPatchLite/hpatch_lite.h

@@ -1,91 +0,0 @@
-//hpatch_lite.h
-//
-/*
- The MIT License (MIT)
- Copyright (c) 2020-2022 HouSisong All Rights Reserved.
-*/
-
-#ifndef _hpatch_lite_h
-#define _hpatch_lite_h
-#include "hpatch_lite_types.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef _IS_WTITE_NEW_BY_PAGE
-#   define _IS_WTITE_NEW_BY_PAGE   0
-#endif
-
-//-----------------------------------------------------------------------------------------------------------------
-// hpatch_lite by stream: hpatch_lite_open()+hpatch_lite_patch() compiled by Mbed Studio is 662 bytes
-//   hdiffpatch v4.2.3, other patcher compiled by Mbed Studio:
-//      patch_single_stream() 2356 bytes (hpatch_StreamPos_t=hpatch_uint32_t)
-//      patch_decompress_with_cache() 2846 bytes (_IS_NEED_CACHE_OLD_BY_COVERS=0,hpatch_StreamPos_t=hpatch_uint32_t)
-
-//diff_data must created by create_lite_diff()
-
-typedef struct hpatchi_listener_t{
-    hpi_TInputStreamHandle  diff_data;
-    hpi_TInputStream_read   read_diff;
-    //must read data_size data to out_data, from read_from_pos of stream; if read error return hpi_FALSE;
-    hpi_BOOL (*read_old)(struct hpatchi_listener_t* listener,hpi_pos_t read_from_pos,hpi_byte* out_data,hpi_size_t data_size);
-    //must write data_size data to sequence stream; if write error return hpi_FALSE;
-    hpi_BOOL (*write_new)(struct hpatchi_listener_t* listener,const hpi_byte* data,hpi_size_t data_size);
-} hpatchi_listener_t;
-
-//hpatch_lite open
-// read lite headinfo from diff_data
-// if diff_data uncompress(*out_compress_type==hpi_compressType_no), *out_uncompressSize==0;
-// if (*out_compress_type!=hpi_compressType_no), you need open compressed data by decompresser 
-//      (see https://github.com/sisong/HPatchLite/decompresser_demo.h & https://github.com/sisong/HPatchLite/hpatchi.c)
-hpi_BOOL hpatch_lite_open(hpi_TInputStreamHandle diff_data,hpi_TInputStream_read read_diff,
-                          hpi_compressType* out_compress_type,hpi_pos_t* out_newSize,hpi_pos_t* out_uncompressSize);
-//hpatch_lite patch
-//	used temp_cache_size memory + {decompress buffer*1}
-//  note: temp_cache_size>=hpi_kMinCacheSize
-hpi_BOOL hpatch_lite_patch(hpatchi_listener_t* listener,hpi_pos_t newSize,
-                           hpi_byte* temp_cache,hpi_size_t temp_cache_size);
-
-
-//-----------------------------------------------------------------------------------------------------------------
-// hpatch_lite inplace-patch by extra: 
-//  hpatchi_inplace_open()+hpatchi_inplaceB() compiled by Mbed Studio is 976 bytes
-//  hpatchi_inplace_open()+hpatchi_inplaceB_by_page() compiled by Mbed Studio is 1116 bytes
-
-//inplace-patch open
-//  diff_data created by create_inplace_lite_diff() or create_inplaceA_lite_diff() or create_inplaceB_lite_diff();
-hpi_BOOL hpatchi_inplace_open(hpi_TInputStreamHandle diff_data,hpi_TInputStream_read read_diff,
-                              hpi_compressType* out_compress_type,hpi_pos_t* out_newSize,
-                              hpi_pos_t* out_uncompressSize,hpi_size_t* out_extraSafeSize);
-
-//inplace-patch for inplaceA format
-//  diff_data created by (create_inplace_lite_diff() with extraSafeSize==0) or create_inplaceA_lite_diff();
-static hpi_force_inline hpi_BOOL hpatchi_inplaceA(hpatchi_listener_t* listener,hpi_pos_t newSize,
-                                                  hpi_byte* temp_cache,hpi_size_t temp_cache_size){
-    return hpatch_lite_patch(listener,newSize,temp_cache,temp_cache_size);
-}
-
-
-#if (_IS_WTITE_NEW_BY_PAGE==0)
-
-//inplace-patch for inplaceB format
-//  used extraSafeSize extra memory for safe, prevent writing to old data areas that are still useful;
-//  diff_data created by (create_inplace_lite_diff() with extraSafeSize>0) or create_inplaceB_lite_diff();
-//  this function is also compatible apply inplaceA format;
-//  note: temp_cache_size>=hpi_kMinInplaceCacheSize+extraSafeSize; hpatchi_inplaceB() used hpatch_lite_patch();
-hpi_BOOL hpatchi_inplaceB(hpatchi_listener_t* listener,hpi_pos_t newSize,
-                          hpi_byte* temp_cache,hpi_size_t extraSafeSize_in_temp_cache,hpi_size_t temp_cache_size);
-
-#else //_IS_WTITE_NEW_BY_PAGE!=0
-
-//same as hpatchi_inplaceB, but write new data by page every time;
-//  note: temp_cache_size>=hpi_kMinInplaceCacheSize+extraSafeSize+pageSize;
-hpi_BOOL hpatchi_inplaceB_by_page(hpatchi_listener_t* listener,hpi_pos_t newSize,hpi_byte* temp_cache,
-                                  hpi_size_t extraSafeSize_in_temp_cache,hpi_size_t pageSize_in_temp_cache,hpi_size_t temp_cache_size);
-
-#endif //_IS_WTITE_NEW_BY_PAGE
-
-#ifdef __cplusplus
-}
-#endif
-#endif //_hpatch_lite_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HPatchLite/hpatch_lite_input_cache.h

@@ -1,31 +0,0 @@
-//hpatch_lite_input_cache.h
-//
-/*
- The MIT License (MIT)
- Copyright (c) 2020-2022 HouSisong All Rights Reserved.
-*/
-#ifndef _hpatch_lite_input_cache_h
-#define _hpatch_lite_input_cache_h
-#include "hpatch_lite_types.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct _hpi_TInputCache{
-    hpi_size_t      cache_begin;
-    hpi_size_t      cache_end;
-    hpi_byte*       cache_buf;
-    hpi_TInputStreamHandle  inputStream;
-    hpi_TInputStream_read   read_code;
-} _hpi_TInputCache;
-
-static hpi_force_inline 
-hpi_BOOL _hpi_cache_success_finish(const _hpi_TInputCache* self){ return (self->cache_end!=0); }
-
-hpi_fast_uint8 _hpi_cache_read_1byte(struct _hpi_TInputCache* self);
-hpi_BOOL       _hpi_cache_update(struct _hpi_TInputCache* self);
-
-#ifdef __cplusplus
-}
-#endif
-#endif //_hpatch_lite_input_cache_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HPatchLite/hpatch_lite_types.h

@@ -1,106 +0,0 @@
-//hpatch_lite_type.h
-//
-/*
- The MIT License (MIT)
- Copyright (c) 2020-2022 HouSisong All Rights Reserved.
-*/
-
-#ifndef _hpatch_lite_type_h
-#define _hpatch_lite_type_h
-#ifdef NDEBUG
-# ifndef assert
-#   define  assert(expression) ((void)0)
-# endif
-#else
-#   include <assert.h> //assert
-#endif
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef hpi_byte
-    typedef     unsigned char   hpi_byte;
-#endif
-#ifndef hpi_fast_uint8
-    typedef     unsigned int    hpi_fast_uint8; //>= 8bit uint
-#endif
-#ifndef hpi_BOOL
-    typedef     hpi_fast_uint8  hpi_BOOL;
-#endif
-#define         hpi_FALSE       0
-#define         hpi_TRUE        1
-#ifndef hpi_size_t
-    typedef     unsigned int    hpi_size_t; //memory size type
-#endif
-#ifndef hpi_pos_t
-    typedef     unsigned int    hpi_pos_t; //file size type
-#endif
-
-#ifndef hpi_inline
-#if (defined(_MSC_VER))
-#   define hpi_inline __inline
-#else
-#   define hpi_inline inline
-#endif
-#endif
-#ifndef hpi_force_inline
-#if defined(_MSC_VER)
-#   define hpi_force_inline __forceinline
-#elif defined(__GNUC__) || defined(__clang__) || defined(__CC_ARM)
-#   define hpi_force_inline __attribute__((always_inline)) inline
-#elif defined(__ICCARM__)
-#   define hpi_force_inline _Pragma("inline=forced")
-#else
-#   define hpi_force_inline hpi_inline
-#endif
-#endif
-
-#ifndef hpi_try_inline
-//#   define hpi_try_inline hpi_inline
-#   define hpi_try_inline
-#endif
-
-
-#ifndef _IS_RUN_MEM_SAFE_CHECK 
-#   define _IS_RUN_MEM_SAFE_CHECK 1
-#endif
-
-#ifndef hpi_TInputStreamHandle
-    typedef void*   hpi_TInputStreamHandle;
-#endif
-
-//read (*data_size) data to out_data from sequence stream; if input stream end,set *data_size readed size; if read error return hpi_FALSE;
-typedef hpi_BOOL (*hpi_TInputStream_read)(hpi_TInputStreamHandle inputStream,hpi_byte* out_data,hpi_size_t* data_size);
-
-#ifndef hpi_kHeadSize
-#   define hpi_kHeadSize        (2+1+1) //"hI" + hpi_compressType + (versionCode+newSize bytes+uncompressSize bytes) { + newSize + uncompressSize}
-#endif
-#ifndef hpi_kInplaceHeadSize
-#   define hpi_kInplaceHeadSize (hpi_kHeadSize+1) //"hI" + hpi_compressType + (inplaceCode+newSize bytes+uncompressSize bytes) + (extraSafeSize bytes) { + newSize + uncompressSize + extraSafeSize}
-#endif
-
-#ifndef hpi_kMinCacheSize
-#   define hpi_kMinCacheSize            (1*2)
-#endif
-#ifndef hpi_kMinInlpaceCacheSize
-#   define hpi_kMinInplaceCacheSize     (1*3)
-#endif
-
-typedef enum hpi_compressType{
-    hpi_compressType_no=0,
-    hpi_compressType_tuz=1, //tinyuz
-    hpi_compressType_zlib=2, //deflate format
-    hpi_compressType_lzma=3,
-    hpi_compressType_lzma2=4,
-    hpi_compressType_zstd=5,
-    hpi_compressType_bzip2=6,
-    hpi_compressType_lz4=7,
-    hpi_compressType_brotli=8,
-    hpi_compressType_lzham=9,
-    //...
-} hpi_compressType;
-
-#ifdef __cplusplus
-}
-#endif
-#endif //_hpatch_lite_type_h