target/linux/generic/patches-4.4/531-debloat_lzma.patch

   1 --- a/include/linux/lzma/LzmaDec.h
   2 +++ b/include/linux/lzma/LzmaDec.h
   3 @@ -31,14 +31,6 @@ typedef struct _CLzmaProps
   4    UInt32 dicSize;
   5  } CLzmaProps;
   6
   7 -/* LzmaProps_Decode - decodes properties
   8 -Returns:
   9 -  SZ_OK
  10 -  SZ_ERROR_UNSUPPORTED - Unsupported properties
  11 -*/
  12 -
  13 -SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size);
  14 -
  15
  16  /* ---------- LZMA Decoder state ---------- */
  17
  18 @@ -70,8 +62,6 @@ typedef struct
  19
  20  #define LzmaDec_Construct(p) { (p)->dic = 0; (p)->probs = 0; }
  21
  22 -void LzmaDec_Init(CLzmaDec *p);
  23 -
  24  /* There are two types of LZMA streams:
  25       0) Stream with end mark. That end mark adds about 6 bytes to compressed size.
  26       1) Stream without end mark. You must know exact uncompressed size to decompress such stream. */
  27 @@ -108,97 +98,6 @@ typedef enum
  28
  29  /* ELzmaStatus is used only as output value for function call */
  30
  31 -
  32 -/* ---------- Interfaces ---------- */
  33 -
  34 -/* There are 3 levels of interfaces:
  35 -     1) Dictionary Interface
  36 -     2) Buffer Interface
  37 -     3) One Call Interface
  38 -   You can select any of these interfaces, but don't mix functions from different
  39 -   groups for same object. */
  40 -
  41 -
  42 -/* There are two variants to allocate state for Dictionary Interface:
  43 -     1) LzmaDec_Allocate / LzmaDec_Free
  44 -     2) LzmaDec_AllocateProbs / LzmaDec_FreeProbs
  45 -   You can use variant 2, if you set dictionary buffer manually.
  46 -   For Buffer Interface you must always use variant 1.
  47 -
  48 -LzmaDec_Allocate* can return:
  49 -  SZ_OK
  50 -  SZ_ERROR_MEM         - Memory allocation error
  51 -  SZ_ERROR_UNSUPPORTED - Unsupported properties
  52 -*/
  53 -
  54 -SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc);
  55 -void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc);
  56 -
  57 -SRes LzmaDec_Allocate(CLzmaDec *state, const Byte *prop, unsigned propsSize, ISzAlloc *alloc);
  58 -void LzmaDec_Free(CLzmaDec *state, ISzAlloc *alloc);
  59 -
  60 -/* ---------- Dictionary Interface ---------- */
  61 -
  62 -/* You can use it, if you want to eliminate the overhead for data copying from
  63 -   dictionary to some other external buffer.
  64 -   You must work with CLzmaDec variables directly in this interface.
  65 -
  66 -   STEPS:
  67 -     LzmaDec_Constr()
  68 -     LzmaDec_Allocate()
  69 -     for (each new stream)
  70 -     {
  71 -       LzmaDec_Init()
  72 -       while (it needs more decompression)
  73 -       {
  74 -         LzmaDec_DecodeToDic()
  75 -         use data from CLzmaDec::dic and update CLzmaDec::dicPos
  76 -       }
  77 -     }
  78 -     LzmaDec_Free()
  79 -*/
  80 -
  81 -/* LzmaDec_DecodeToDic
  82 -
  83 -   The decoding to internal dictionary buffer (CLzmaDec::dic).
  84 -   You must manually update CLzmaDec::dicPos, if it reaches CLzmaDec::dicBufSize !!!
  85 -
  86 -finishMode:
  87 -  It has meaning only if the decoding reaches output limit (dicLimit).
  88 -  LZMA_FINISH_ANY - Decode just dicLimit bytes.
  89 -  LZMA_FINISH_END - Stream must be finished after dicLimit.
  90 -
  91 -Returns:
  92 -  SZ_OK
  93 -    status:
  94 -      LZMA_STATUS_FINISHED_WITH_MARK
  95 -      LZMA_STATUS_NOT_FINISHED
  96 -      LZMA_STATUS_NEEDS_MORE_INPUT
  97 -      LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
  98 -  SZ_ERROR_DATA - Data error
  99 -*/
 100 -
 101 -SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit,
 102 -    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
 103 -
 104 -
 105 -/* ---------- Buffer Interface ---------- */
 106 -
 107 -/* It's zlib-like interface.
 108 -   See LzmaDec_DecodeToDic description for information about STEPS and return results,
 109 -   but you must use LzmaDec_DecodeToBuf instead of LzmaDec_DecodeToDic and you don't need
 110 -   to work with CLzmaDec variables manually.
 111 -
 112 -finishMode:
 113 -  It has meaning only if the decoding reaches output limit (*destLen).
 114 -  LZMA_FINISH_ANY - Decode just destLen bytes.
 115 -  LZMA_FINISH_END - Stream must be finished after (*destLen).
 116 -*/
 117 -
 118 -SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen,
 119 -    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
 120 -
 121 -
 122  /* ---------- One Call Interface ---------- */
 123
 124  /* LzmaDecode
 125 --- a/lib/lzma/LzmaDec.c
 126 +++ b/lib/lzma/LzmaDec.c
 127 @@ -682,7 +682,7 @@ static void LzmaDec_InitRc(CLzmaDec *p,
 128    p->needFlush = 0;
 129  }
 130
 131 -void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState)
 132 +static void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState)
 133  {
 134    p->needFlush = 1;
 135    p->remainLen = 0;
 136 @@ -698,7 +698,7 @@ void LzmaDec_InitDicAndState(CLzmaDec *p
 137      p->needInitState = 1;
 138  }
 139
 140 -void LzmaDec_Init(CLzmaDec *p)
 141 +static void LzmaDec_Init(CLzmaDec *p)
 142  {
 143    p->dicPos = 0;
 144    LzmaDec_InitDicAndState(p, True, True);
 145 @@ -716,7 +716,7 @@ static void LzmaDec_InitStateReal(CLzmaD
 146    p->needInitState = 0;
 147  }
 148
 149 -SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *srcLen,
 150 +static SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *srcLen,
 151      ELzmaFinishMode finishMode, ELzmaStatus *status)
 152  {
 153    SizeT inSize = *srcLen;
 154 @@ -837,65 +837,13 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, Si
 155    return (p->code == 0) ? SZ_OK : SZ_ERROR_DATA;
 156  }
 157
 158 -SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
 159 -{
 160 -  SizeT outSize = *destLen;
 161 -  SizeT inSize = *srcLen;
 162 -  *srcLen = *destLen = 0;
 163 -  for (;;)
 164 -  {
 165 -    SizeT inSizeCur = inSize, outSizeCur, dicPos;
 166 -    ELzmaFinishMode curFinishMode;
 167 -    SRes res;
 168 -    if (p->dicPos == p->dicBufSize)
 169 -      p->dicPos = 0;
 170 -    dicPos = p->dicPos;
 171 -    if (outSize > p->dicBufSize - dicPos)
 172 -    {
 173 -      outSizeCur = p->dicBufSize;
 174 -      curFinishMode = LZMA_FINISH_ANY;
 175 -    }
 176 -    else
 177 -    {
 178 -      outSizeCur = dicPos + outSize;
 179 -      curFinishMode = finishMode;
 180 -    }
 181 -
 182 -    res = LzmaDec_DecodeToDic(p, outSizeCur, src, &inSizeCur, curFinishMode, status);
 183 -    src += inSizeCur;
 184 -    inSize -= inSizeCur;
 185 -    *srcLen += inSizeCur;
 186 -    outSizeCur = p->dicPos - dicPos;
 187 -    memcpy(dest, p->dic + dicPos, outSizeCur);
 188 -    dest += outSizeCur;
 189 -    outSize -= outSizeCur;
 190 -    *destLen += outSizeCur;
 191 -    if (res != 0)
 192 -      return res;
 193 -    if (outSizeCur == 0 || outSize == 0)
 194 -      return SZ_OK;
 195 -  }
 196 -}
 197 -
 198 -void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc)
 199 +static void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc)
 200  {
 201    alloc->Free(alloc, p->probs);
 202    p->probs = 0;
 203  }
 204
 205 -static void LzmaDec_FreeDict(CLzmaDec *p, ISzAlloc *alloc)
 206 -{
 207 -  alloc->Free(alloc, p->dic);
 208 -  p->dic = 0;
 209 -}
 210 -
 211 -void LzmaDec_Free(CLzmaDec *p, ISzAlloc *alloc)
 212 -{
 213 -  LzmaDec_FreeProbs(p, alloc);
 214 -  LzmaDec_FreeDict(p, alloc);
 215 -}
 216 -
 217 -SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
 218 +static SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
 219  {
 220    UInt32 dicSize;
 221    Byte d;
 222 @@ -935,33 +883,11 @@ static SRes LzmaDec_AllocateProbs2(CLzma
 223    return SZ_OK;
 224  }
 225
 226 -SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)
 227 -{
 228 -  CLzmaProps propNew;
 229 -  RINOK(LzmaProps_Decode(&propNew, props, propsSize));
 230 -  RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));
 231 -  p->prop = propNew;
 232 -  return SZ_OK;
 233 -}
 234 -
 235 -SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)
 236 +static SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)
 237  {
 238    CLzmaProps propNew;
 239 -  SizeT dicBufSize;
 240    RINOK(LzmaProps_Decode(&propNew, props, propsSize));
 241    RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));
 242 -  dicBufSize = propNew.dicSize;
 243 -  if (p->dic == 0 || dicBufSize != p->dicBufSize)
 244 -  {
 245 -    LzmaDec_FreeDict(p, alloc);
 246 -    p->dic = (Byte *)alloc->Alloc(alloc, dicBufSize);
 247 -    if (p->dic == 0)
 248 -    {
 249 -      LzmaDec_FreeProbs(p, alloc);
 250 -      return SZ_ERROR_MEM;
 251 -    }
 252 -  }
 253 -  p->dicBufSize = dicBufSize;
 254    p->prop = propNew;
 255    return SZ_OK;
 256  }
 257 --- a/include/linux/lzma/LzmaEnc.h
 258 +++ b/include/linux/lzma/LzmaEnc.h
 259 @@ -31,9 +31,6 @@ typedef struct _CLzmaEncProps
 260  } CLzmaEncProps;
 261
 262  void LzmaEncProps_Init(CLzmaEncProps *p);
 263 -void LzmaEncProps_Normalize(CLzmaEncProps *p);
 264 -UInt32 LzmaEncProps_GetDictSize(const CLzmaEncProps *props2);
 265 -
 266
 267  /* ---------- CLzmaEncHandle Interface ---------- */
 268
 269 @@ -53,26 +50,9 @@ CLzmaEncHandle LzmaEnc_Create(ISzAlloc *
 270  void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAlloc *alloc, ISzAlloc *allocBig);
 271  SRes LzmaEnc_SetProps(CLzmaEncHandle p, const CLzmaEncProps *props);
 272  SRes LzmaEnc_WriteProperties(CLzmaEncHandle p, Byte *properties, SizeT *size);
 273 -SRes LzmaEnc_Encode(CLzmaEncHandle p, ISeqOutStream *outStream, ISeqInStream *inStream,
 274 -    ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);
 275  SRes LzmaEnc_MemEncode(CLzmaEncHandle p, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
 276      int writeEndMark, ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);
 277
 278 -/* ---------- One Call Interface ---------- */
 279 -
 280 -/* LzmaEncode
 281 -Return code:
 282 -  SZ_OK               - OK
 283 -  SZ_ERROR_MEM        - Memory allocation error
 284 -  SZ_ERROR_PARAM      - Incorrect paramater
 285 -  SZ_ERROR_OUTPUT_EOF - output buffer overflow
 286 -  SZ_ERROR_THREAD     - errors in multithreading functions (only for Mt version)
 287 -*/
 288 -
 289 -SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
 290 -    const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
 291 -    ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);
 292 -
 293  #ifdef __cplusplus
 294  }
 295  #endif
 296 --- a/lib/lzma/LzmaEnc.c
 297 +++ b/lib/lzma/LzmaEnc.c
 298 @@ -53,7 +53,7 @@ void LzmaEncProps_Init(CLzmaEncProps *p)
 299    p->writeEndMark = 0;
 300  }
 301
 302 -void LzmaEncProps_Normalize(CLzmaEncProps *p)
 303 +static void LzmaEncProps_Normalize(CLzmaEncProps *p)
 304  {
 305    int level = p->level;
 306    if (level < 0) level = 5;
 307 @@ -76,7 +76,7 @@ void LzmaEncProps_Normalize(CLzmaEncProp
 308        #endif
 309  }
 310
 311 -UInt32 LzmaEncProps_GetDictSize(const CLzmaEncProps *props2)
 312 +static UInt32 __maybe_unused LzmaEncProps_GetDictSize(const CLzmaEncProps *props2)
 313  {
 314    CLzmaEncProps props = *props2;
 315    LzmaEncProps_Normalize(&props);
 316 @@ -93,7 +93,7 @@ UInt32 LzmaEncProps_GetDictSize(const CL
 317
 318  #define BSR2_RET(pos, res) { unsigned long i; _BitScanReverse(&i, (pos)); res = (i + i) + ((pos >> (i - 1)) & 1); }
 319
 320 -UInt32 GetPosSlot1(UInt32 pos)
 321 +static UInt32 GetPosSlot1(UInt32 pos)
 322  {
 323    UInt32 res;
 324    BSR2_RET(pos, res);
 325 @@ -107,7 +107,7 @@ UInt32 GetPosSlot1(UInt32 pos)
 326  #define kNumLogBits (9 + (int)sizeof(size_t) / 2)
 327  #define kDicLogSizeMaxCompress ((kNumLogBits - 1) * 2 + 7)
 328
 329 -void LzmaEnc_FastPosInit(Byte *g_FastPos)
 330 +static void LzmaEnc_FastPosInit(Byte *g_FastPos)
 331  {
 332    int c = 2, slotFast;
 333    g_FastPos[0] = 0;
 334 @@ -339,58 +339,6 @@ typedef struct
 335    CSaveState saveState;
 336  } CLzmaEnc;
 337
 338 -void LzmaEnc_SaveState(CLzmaEncHandle pp)
 339 -{
 340 -  CLzmaEnc *p = (CLzmaEnc *)pp;
 341 -  CSaveState *dest = &p->saveState;
 342 -  int i;
 343 -  dest->lenEnc = p->lenEnc;
 344 -  dest->repLenEnc = p->repLenEnc;
 345 -  dest->state = p->state;
 346 -
 347 -  for (i = 0; i < kNumStates; i++)
 348 -  {
 349 -    memcpy(dest->isMatch[i], p->isMatch[i], sizeof(p->isMatch[i]));
 350 -    memcpy(dest->isRep0Long[i], p->isRep0Long[i], sizeof(p->isRep0Long[i]));
 351 -  }
 352 -  for (i = 0; i < kNumLenToPosStates; i++)
 353 -    memcpy(dest->posSlotEncoder[i], p->posSlotEncoder[i], sizeof(p->posSlotEncoder[i]));
 354 -  memcpy(dest->isRep, p->isRep, sizeof(p->isRep));
 355 -  memcpy(dest->isRepG0, p->isRepG0, sizeof(p->isRepG0));
 356 -  memcpy(dest->isRepG1, p->isRepG1, sizeof(p->isRepG1));
 357 -  memcpy(dest->isRepG2, p->isRepG2, sizeof(p->isRepG2));
 358 -  memcpy(dest->posEncoders, p->posEncoders, sizeof(p->posEncoders));
 359 -  memcpy(dest->posAlignEncoder, p->posAlignEncoder, sizeof(p->posAlignEncoder));
 360 -  memcpy(dest->reps, p->reps, sizeof(p->reps));
 361 -  memcpy(dest->litProbs, p->litProbs, (0x300 << p->lclp) * sizeof(CLzmaProb));
 362 -}
 363 -
 364 -void LzmaEnc_RestoreState(CLzmaEncHandle pp)
 365 -{
 366 -  CLzmaEnc *dest = (CLzmaEnc *)pp;
 367 -  const CSaveState *p = &dest->saveState;
 368 -  int i;
 369 -  dest->lenEnc = p->lenEnc;
 370 -  dest->repLenEnc = p->repLenEnc;
 371 -  dest->state = p->state;
 372 -
 373 -  for (i = 0; i < kNumStates; i++)
 374 -  {
 375 -    memcpy(dest->isMatch[i], p->isMatch[i], sizeof(p->isMatch[i]));
 376 -    memcpy(dest->isRep0Long[i], p->isRep0Long[i], sizeof(p->isRep0Long[i]));
 377 -  }
 378 -  for (i = 0; i < kNumLenToPosStates; i++)
 379 -    memcpy(dest->posSlotEncoder[i], p->posSlotEncoder[i], sizeof(p->posSlotEncoder[i]));
 380 -  memcpy(dest->isRep, p->isRep, sizeof(p->isRep));
 381 -  memcpy(dest->isRepG0, p->isRepG0, sizeof(p->isRepG0));
 382 -  memcpy(dest->isRepG1, p->isRepG1, sizeof(p->isRepG1));
 383 -  memcpy(dest->isRepG2, p->isRepG2, sizeof(p->isRepG2));
 384 -  memcpy(dest->posEncoders, p->posEncoders, sizeof(p->posEncoders));
 385 -  memcpy(dest->posAlignEncoder, p->posAlignEncoder, sizeof(p->posAlignEncoder));
 386 -  memcpy(dest->reps, p->reps, sizeof(p->reps));
 387 -  memcpy(dest->litProbs, p->litProbs, (0x300 << dest->lclp) * sizeof(CLzmaProb));
 388 -}
 389 -
 390  SRes LzmaEnc_SetProps(CLzmaEncHandle pp, const CLzmaEncProps *props2)
 391  {
 392    CLzmaEnc *p = (CLzmaEnc *)pp;
 393 @@ -600,7 +548,7 @@ static void LitEnc_EncodeMatched(CRangeE
 394    while (symbol < 0x10000);
 395  }
 396
 397 -void LzmaEnc_InitPriceTables(UInt32 *ProbPrices)
 398 +static void LzmaEnc_InitPriceTables(UInt32 *ProbPrices)
 399  {
 400    UInt32 i;
 401    for (i = (1 << kNumMoveReducingBits) / 2; i < kBitModelTotal; i += (1 << kNumMoveReducingBits))
 402 @@ -1676,7 +1624,7 @@ static void FillDistancesPrices(CLzmaEnc
 403    p->matchPriceCount = 0;
 404  }
 405
 406 -void LzmaEnc_Construct(CLzmaEnc *p)
 407 +static void LzmaEnc_Construct(CLzmaEnc *p)
 408  {
 409    RangeEnc_Construct(&p->rc);
 410    MatchFinder_Construct(&p->matchFinderBase);
 411 @@ -1709,7 +1657,7 @@ CLzmaEncHandle LzmaEnc_Create(ISzAlloc *
 412    return p;
 413  }
 414
 415 -void LzmaEnc_FreeLits(CLzmaEnc *p, ISzAlloc *alloc)
 416 +static void LzmaEnc_FreeLits(CLzmaEnc *p, ISzAlloc *alloc)
 417  {
 418    alloc->Free(alloc, p->litProbs);
 419    alloc->Free(alloc, p->saveState.litProbs);
 420 @@ -1717,7 +1665,7 @@ void LzmaEnc_FreeLits(CLzmaEnc *p, ISzAl
 421    p->saveState.litProbs = 0;
 422  }
 423
 424 -void LzmaEnc_Destruct(CLzmaEnc *p, ISzAlloc *alloc, ISzAlloc *allocBig)
 425 +static void LzmaEnc_Destruct(CLzmaEnc *p, ISzAlloc *alloc, ISzAlloc *allocBig)
 426  {
 427    #ifndef _7ZIP_ST
 428    MatchFinderMt_Destruct(&p->matchFinderMt, allocBig);
 429 @@ -1947,7 +1895,7 @@ static SRes LzmaEnc_Alloc(CLzmaEnc *p, U
 430    return SZ_OK;
 431  }
 432
 433 -void LzmaEnc_Init(CLzmaEnc *p)
 434 +static void LzmaEnc_Init(CLzmaEnc *p)
 435  {
 436    UInt32 i;
 437    p->state = 0;
 438 @@ -2005,7 +1953,7 @@ void LzmaEnc_Init(CLzmaEnc *p)
 439    p->lpMask = (1 << p->lp) - 1;
 440  }
 441
 442 -void LzmaEnc_InitPrices(CLzmaEnc *p)
 443 +static void LzmaEnc_InitPrices(CLzmaEnc *p)
 444  {
 445    if (!p->fastMode)
 446    {
 447 @@ -2037,26 +1985,6 @@ static SRes LzmaEnc_AllocAndInit(CLzmaEn
 448    return SZ_OK;
 449  }
 450
 451 -static SRes LzmaEnc_Prepare(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream,
 452 -    ISzAlloc *alloc, ISzAlloc *allocBig)
 453 -{
 454 -  CLzmaEnc *p = (CLzmaEnc *)pp;
 455 -  p->matchFinderBase.stream = inStream;
 456 -  p->needInit = 1;
 457 -  p->rc.outStream = outStream;
 458 -  return LzmaEnc_AllocAndInit(p, 0, alloc, allocBig);
 459 -}
 460 -
 461 -SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle pp,
 462 -    ISeqInStream *inStream, UInt32 keepWindowSize,
 463 -    ISzAlloc *alloc, ISzAlloc *allocBig)
 464 -{
 465 -  CLzmaEnc *p = (CLzmaEnc *)pp;
 466 -  p->matchFinderBase.stream = inStream;
 467 -  p->needInit = 1;
 468 -  return LzmaEnc_AllocAndInit(p, keepWindowSize, alloc, allocBig);
 469 -}
 470 -
 471  static void LzmaEnc_SetInputBuf(CLzmaEnc *p, const Byte *src, SizeT srcLen)
 472  {
 473    p->matchFinderBase.directInput = 1;
 474 @@ -2064,7 +1992,7 @@ static void LzmaEnc_SetInputBuf(CLzmaEnc
 475    p->matchFinderBase.directInputRem = srcLen;
 476  }
 477
 478 -SRes LzmaEnc_MemPrepare(CLzmaEncHandle pp, const Byte *src, SizeT srcLen,
 479 +static SRes LzmaEnc_MemPrepare(CLzmaEncHandle pp, const Byte *src, SizeT srcLen,
 480      UInt32 keepWindowSize, ISzAlloc *alloc, ISzAlloc *allocBig)
 481  {
 482    CLzmaEnc *p = (CLzmaEnc *)pp;
 483 @@ -2074,7 +2002,7 @@ SRes LzmaEnc_MemPrepare(CLzmaEncHandle p
 484    return LzmaEnc_AllocAndInit(p, keepWindowSize, alloc, allocBig);
 485  }
 486
 487 -void LzmaEnc_Finish(CLzmaEncHandle pp)
 488 +static void LzmaEnc_Finish(CLzmaEncHandle pp)
 489  {
 490    #ifndef _7ZIP_ST
 491    CLzmaEnc *p = (CLzmaEnc *)pp;
 492 @@ -2107,53 +2035,6 @@ static size_t MyWrite(void *pp, const vo
 493    return size;
 494  }
 495
 496 -
 497 -UInt32 LzmaEnc_GetNumAvailableBytes(CLzmaEncHandle pp)
 498 -{
 499 -  const CLzmaEnc *p = (CLzmaEnc *)pp;
 500 -  return p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);
 501 -}
 502 -
 503 -const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle pp)
 504 -{
 505 -  const CLzmaEnc *p = (CLzmaEnc *)pp;
 506 -  return p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - p->additionalOffset;
 507 -}
 508 -
 509 -SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, Bool reInit,
 510 -    Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize)
 511 -{
 512 -  CLzmaEnc *p = (CLzmaEnc *)pp;
 513 -  UInt64 nowPos64;
 514 -  SRes res;
 515 -  CSeqOutStreamBuf outStream;
 516 -
 517 -  outStream.funcTable.Write = MyWrite;
 518 -  outStream.data = dest;
 519 -  outStream.rem = *destLen;
 520 -  outStream.overflow = False;
 521 -
 522 -  p->writeEndMark = False;
 523 -  p->finished = False;
 524 -  p->result = SZ_OK;
 525 -
 526 -  if (reInit)
 527 -    LzmaEnc_Init(p);
 528 -  LzmaEnc_InitPrices(p);
 529 -  nowPos64 = p->nowPos64;
 530 -  RangeEnc_Init(&p->rc);
 531 -  p->rc.outStream = &outStream.funcTable;
 532 -
 533 -  res = LzmaEnc_CodeOneBlock(p, True, desiredPackSize, *unpackSize);
 534 -
 535 -  *unpackSize = (UInt32)(p->nowPos64 - nowPos64);
 536 -  *destLen -= outStream.rem;
 537 -  if (outStream.overflow)
 538 -    return SZ_ERROR_OUTPUT_EOF;
 539 -
 540 -  return res;
 541 -}
 542 -
 543  static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgress *progress)
 544  {
 545    SRes res = SZ_OK;
 546 @@ -2184,13 +2065,6 @@ static SRes LzmaEnc_Encode2(CLzmaEnc *p,
 547    return res;
 548  }
 549
 550 -SRes LzmaEnc_Encode(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress,
 551 -    ISzAlloc *alloc, ISzAlloc *allocBig)
 552 -{
 553 -  RINOK(LzmaEnc_Prepare(pp, outStream, inStream, alloc, allocBig));
 554 -  return LzmaEnc_Encode2((CLzmaEnc *)pp, progress);
 555 -}
 556 -
 557  SRes LzmaEnc_WriteProperties(CLzmaEncHandle pp, Byte *props, SizeT *size)
 558  {
 559    CLzmaEnc *p = (CLzmaEnc *)pp;
 560 @@ -2247,25 +2121,3 @@ SRes LzmaEnc_MemEncode(CLzmaEncHandle pp
 561      return SZ_ERROR_OUTPUT_EOF;
 562    return res;
 563  }
 564 -
 565 -SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
 566 -    const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
 567 -    ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig)
 568 -{
 569 -  CLzmaEnc *p = (CLzmaEnc *)LzmaEnc_Create(alloc);
 570 -  SRes res;
 571 -  if (p == 0)
 572 -    return SZ_ERROR_MEM;
 573 -
 574 -  res = LzmaEnc_SetProps(p, props);
 575 -  if (res == SZ_OK)
 576 -  {
 577 -    res = LzmaEnc_WriteProperties(p, propsEncoded, propsSize);
 578 -    if (res == SZ_OK)
 579 -      res = LzmaEnc_MemEncode(p, dest, destLen, src, srcLen,
 580 -          writeEndMark, progress, alloc, allocBig);
 581 -  }
 582 -
 583 -  LzmaEnc_Destroy(p, alloc, allocBig);
 584 -  return res;
 585 -}
 586 --- a/include/linux/lzma/LzFind.h
 587 +++ b/include/linux/lzma/LzFind.h
 588 @@ -55,11 +55,6 @@ typedef struct _CMatchFinder
 589
 590  #define Inline_MatchFinder_GetNumAvailableBytes(p) ((p)->streamPos - (p)->pos)
 591
 592 -int MatchFinder_NeedMove(CMatchFinder *p);
 593 -Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p);
 594 -void MatchFinder_MoveBlock(CMatchFinder *p);
 595 -void MatchFinder_ReadIfRequired(CMatchFinder *p);
 596 -
 597  void MatchFinder_Construct(CMatchFinder *p);
 598
 599  /* Conditions:
 600 @@ -70,12 +65,6 @@ int MatchFinder_Create(CMatchFinder *p,
 601      UInt32 keepAddBufferBefore, UInt32 matchMaxLen, UInt32 keepAddBufferAfter,
 602      ISzAlloc *alloc);
 603  void MatchFinder_Free(CMatchFinder *p, ISzAlloc *alloc);
 604 -void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, UInt32 numItems);
 605 -void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue);
 606 -
 607 -UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *buffer, CLzRef *son,
 608 -    UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 _cutValue,
 609 -    UInt32 *distances, UInt32 maxLen);
 610
 611  /*
 612  Conditions:
 613 @@ -102,12 +91,6 @@ typedef struct _IMatchFinder
 614
 615  void MatchFinder_CreateVTable(CMatchFinder *p, IMatchFinder *vTable);
 616
 617 -void MatchFinder_Init(CMatchFinder *p);
 618 -UInt32 Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
 619 -UInt32 Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
 620 -void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
 621 -void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
 622 -
 623  #ifdef __cplusplus
 624  }
 625  #endif
 626 --- a/lib/lzma/LzFind.c
 627 +++ b/lib/lzma/LzFind.c
 628 @@ -14,9 +14,15 @@
 629
 630  #define kStartMaxLen 3
 631
 632 +#if 0
 633 +#define DIRECT_INPUT   p->directInput
 634 +#else
 635 +#define DIRECT_INPUT   1
 636 +#endif
 637 +
 638  static void LzInWindow_Free(CMatchFinder *p, ISzAlloc *alloc)
 639  {
 640 -  if (!p->directInput)
 641 +  if (!DIRECT_INPUT)
 642    {
 643      alloc->Free(alloc, p->bufferBase);
 644      p->bufferBase = 0;
 645 @@ -28,7 +34,7 @@ static void LzInWindow_Free(CMatchFinder
 646  static int LzInWindow_Create(CMatchFinder *p, UInt32 keepSizeReserv, ISzAlloc *alloc)
 647  {
 648    UInt32 blockSize = p->keepSizeBefore + p->keepSizeAfter + keepSizeReserv;
 649 -  if (p->directInput)
 650 +  if (DIRECT_INPUT)
 651    {
 652      p->blockSize = blockSize;
 653      return 1;
 654 @@ -42,12 +48,12 @@ static int LzInWindow_Create(CMatchFinde
 655    return (p->bufferBase != 0);
 656  }
 657
 658 -Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p) { return p->buffer; }
 659 -Byte MatchFinder_GetIndexByte(CMatchFinder *p, Int32 index) { return p->buffer[index]; }
 660 +static Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p) { return p->buffer; }
 661 +static Byte MatchFinder_GetIndexByte(CMatchFinder *p, Int32 index) { return p->buffer[index]; }
 662
 663 -UInt32 MatchFinder_GetNumAvailableBytes(CMatchFinder *p) { return p->streamPos - p->pos; }
 664 +static UInt32 MatchFinder_GetNumAvailableBytes(CMatchFinder *p) { return p->streamPos - p->pos; }
 665
 666 -void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue)
 667 +static void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue)
 668  {
 669    p->posLimit -= subValue;
 670    p->pos -= subValue;
 671 @@ -58,7 +64,7 @@ static void MatchFinder_ReadBlock(CMatch
 672  {
 673    if (p->streamEndWasReached || p->result != SZ_OK)
 674      return;
 675 -  if (p->directInput)
 676 +  if (DIRECT_INPUT)
 677    {
 678      UInt32 curSize = 0xFFFFFFFF - p->streamPos;
 679      if (curSize > p->directInputRem)
 680 @@ -89,7 +95,7 @@ static void MatchFinder_ReadBlock(CMatch
 681    }
 682  }
 683
 684 -void MatchFinder_MoveBlock(CMatchFinder *p)
 685 +static void MatchFinder_MoveBlock(CMatchFinder *p)
 686  {
 687    memmove(p->bufferBase,
 688      p->buffer - p->keepSizeBefore,
 689 @@ -97,22 +103,14 @@ void MatchFinder_MoveBlock(CMatchFinder
 690    p->buffer = p->bufferBase + p->keepSizeBefore;
 691  }
 692
 693 -int MatchFinder_NeedMove(CMatchFinder *p)
 694 +static int MatchFinder_NeedMove(CMatchFinder *p)
 695  {
 696 -  if (p->directInput)
 697 +  if (DIRECT_INPUT)
 698      return 0;
 699    /* if (p->streamEndWasReached) return 0; */
 700    return ((size_t)(p->bufferBase + p->blockSize - p->buffer) <= p->keepSizeAfter);
 701  }
 702
 703 -void MatchFinder_ReadIfRequired(CMatchFinder *p)
 704 -{
 705 -  if (p->streamEndWasReached)
 706 -    return;
 707 -  if (p->keepSizeAfter >= p->streamPos - p->pos)
 708 -    MatchFinder_ReadBlock(p);
 709 -}
 710 -
 711  static void MatchFinder_CheckAndMoveAndRead(CMatchFinder *p)
 712  {
 713    if (MatchFinder_NeedMove(p))
 714 @@ -268,7 +266,7 @@ static void MatchFinder_SetLimits(CMatch
 715    p->posLimit = p->pos + limit;
 716  }
 717
 718 -void MatchFinder_Init(CMatchFinder *p)
 719 +static void MatchFinder_Init(CMatchFinder *p)
 720  {
 721    UInt32 i;
 722    for (i = 0; i < p->hashSizeSum; i++)
 723 @@ -287,7 +285,7 @@ static UInt32 MatchFinder_GetSubValue(CM
 724    return (p->pos - p->historySize - 1) & kNormalizeMask;
 725  }
 726
 727 -void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, UInt32 numItems)
 728 +static void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, UInt32 numItems)
 729  {
 730    UInt32 i;
 731    for (i = 0; i < numItems; i++)
 732 @@ -319,38 +317,7 @@ static void MatchFinder_CheckLimits(CMat
 733    MatchFinder_SetLimits(p);
 734  }
 735
 736 -static UInt32 * Hc_GetMatchesSpec(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
 737 -    UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue,
 738 -    UInt32 *distances, UInt32 maxLen)
 739 -{
 740 -  son[_cyclicBufferPos] = curMatch;
 741 -  for (;;)
 742 -  {
 743 -    UInt32 delta = pos - curMatch;
 744 -    if (cutValue-- == 0 || delta >= _cyclicBufferSize)
 745 -      return distances;
 746 -    {
 747 -      const Byte *pb = cur - delta;
 748 -      curMatch = son[_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)];
 749 -      if (pb[maxLen] == cur[maxLen] && *pb == *cur)
 750 -      {
 751 -        UInt32 len = 0;
 752 -        while (++len != lenLimit)
 753 -          if (pb[len] != cur[len])
 754 -            break;
 755 -        if (maxLen < len)
 756 -        {
 757 -          *distances++ = maxLen = len;
 758 -          *distances++ = delta - 1;
 759 -          if (len == lenLimit)
 760 -            return distances;
 761 -        }
 762 -      }
 763 -    }
 764 -  }
 765 -}
 766 -
 767 -UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
 768 +static UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
 769      UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue,
 770      UInt32 *distances, UInt32 maxLen)
 771  {
 772 @@ -460,10 +427,10 @@ static void SkipMatchesSpec(UInt32 lenLi
 773    p->buffer++; \
 774    if (++p->pos == p->posLimit) MatchFinder_CheckLimits(p);
 775
 776 -#define MOVE_POS_RET MOVE_POS return offset;
 777 -
 778  static void MatchFinder_MovePos(CMatchFinder *p) { MOVE_POS; }
 779
 780 +#define MOVE_POS_RET MatchFinder_MovePos(p); return offset;
 781 +
 782  #define GET_MATCHES_HEADER2(minLen, ret_op) \
 783    UInt32 lenLimit; UInt32 hashValue; const Byte *cur; UInt32 curMatch; \
 784    lenLimit = p->lenLimit; { if (lenLimit < minLen) { MatchFinder_MovePos(p); ret_op; }} \
 785 @@ -479,62 +446,7 @@ static void MatchFinder_MovePos(CMatchFi
 786    distances + offset, maxLen) - distances); MOVE_POS_RET;
 787
 788  #define SKIP_FOOTER \
 789 -  SkipMatchesSpec(lenLimit, curMatch, MF_PARAMS(p)); MOVE_POS;
 790 -
 791 -static UInt32 Bt2_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
 792 -{
 793 -  UInt32 offset;
 794 -  GET_MATCHES_HEADER(2)
 795 -  HASH2_CALC;
 796 -  curMatch = p->hash[hashValue];
 797 -  p->hash[hashValue] = p->pos;
 798 -  offset = 0;
 799 -  GET_MATCHES_FOOTER(offset, 1)
 800 -}
 801 -
 802 -UInt32 Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
 803 -{
 804 -  UInt32 offset;
 805 -  GET_MATCHES_HEADER(3)
 806 -  HASH_ZIP_CALC;
 807 -  curMatch = p->hash[hashValue];
 808 -  p->hash[hashValue] = p->pos;
 809 -  offset = 0;
 810 -  GET_MATCHES_FOOTER(offset, 2)
 811 -}
 812 -
 813 -static UInt32 Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
 814 -{
 815 -  UInt32 hash2Value, delta2, maxLen, offset;
 816 -  GET_MATCHES_HEADER(3)
 817 -
 818 -  HASH3_CALC;
 819 -
 820 -  delta2 = p->pos - p->hash[hash2Value];
 821 -  curMatch = p->hash[kFix3HashSize + hashValue];
 822 -
 823 -  p->hash[hash2Value] =
 824 -  p->hash[kFix3HashSize + hashValue] = p->pos;
 825 -
 826 -
 827 -  maxLen = 2;
 828 -  offset = 0;
 829 -  if (delta2 < p->cyclicBufferSize && *(cur - delta2) == *cur)
 830 -  {
 831 -    for (; maxLen != lenLimit; maxLen++)
 832 -      if (cur[(ptrdiff_t)maxLen - delta2] != cur[maxLen])
 833 -        break;
 834 -    distances[0] = maxLen;
 835 -    distances[1] = delta2 - 1;
 836 -    offset = 2;
 837 -    if (maxLen == lenLimit)
 838 -    {
 839 -      SkipMatchesSpec(lenLimit, curMatch, MF_PARAMS(p));
 840 -      MOVE_POS_RET;
 841 -    }
 842 -  }
 843 -  GET_MATCHES_FOOTER(offset, maxLen)
 844 -}
 845 +  SkipMatchesSpec(lenLimit, curMatch, MF_PARAMS(p)); MatchFinder_MovePos(p);
 846
 847  static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
 848  {
 849 @@ -583,108 +495,6 @@ static UInt32 Bt4_MatchFinder_GetMatches
 850    GET_MATCHES_FOOTER(offset, maxLen)
 851  }
 852
 853 -static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
 854 -{
 855 -  UInt32 hash2Value, hash3Value, delta2, delta3, maxLen, offset;
 856 -  GET_MATCHES_HEADER(4)
 857 -
 858 -  HASH4_CALC;
 859 -
 860 -  delta2 = p->pos - p->hash[                hash2Value];
 861 -  delta3 = p->pos - p->hash[kFix3HashSize + hash3Value];
 862 -  curMatch = p->hash[kFix4HashSize + hashValue];
 863 -
 864 -  p->hash[                hash2Value] =
 865 -  p->hash[kFix3HashSize + hash3Value] =
 866 -  p->hash[kFix4HashSize + hashValue] = p->pos;
 867 -
 868 -  maxLen = 1;
 869 -  offset = 0;
 870 -  if (delta2 < p->cyclicBufferSize && *(cur - delta2) == *cur)
 871 -  {
 872 -    distances[0] = maxLen = 2;
 873 -    distances[1] = delta2 - 1;
 874 -    offset = 2;
 875 -  }
 876 -  if (delta2 != delta3 && delta3 < p->cyclicBufferSize && *(cur - delta3) == *cur)
 877 -  {
 878 -    maxLen = 3;
 879 -    distances[offset + 1] = delta3 - 1;
 880 -    offset += 2;
 881 -    delta2 = delta3;
 882 -  }
 883 -  if (offset != 0)
 884 -  {
 885 -    for (; maxLen != lenLimit; maxLen++)
 886 -      if (cur[(ptrdiff_t)maxLen - delta2] != cur[maxLen])
 887 -        break;
 888 -    distances[offset - 2] = maxLen;
 889 -    if (maxLen == lenLimit)
 890 -    {
 891 -      p->son[p->cyclicBufferPos] = curMatch;
 892 -      MOVE_POS_RET;
 893 -    }
 894 -  }
 895 -  if (maxLen < 3)
 896 -    maxLen = 3;
 897 -  offset = (UInt32)(Hc_GetMatchesSpec(lenLimit, curMatch, MF_PARAMS(p),
 898 -    distances + offset, maxLen) - (distances));
 899 -  MOVE_POS_RET
 900 -}
 901 -
 902 -UInt32 Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
 903 -{
 904 -  UInt32 offset;
 905 -  GET_MATCHES_HEADER(3)
 906 -  HASH_ZIP_CALC;
 907 -  curMatch = p->hash[hashValue];
 908 -  p->hash[hashValue] = p->pos;
 909 -  offset = (UInt32)(Hc_GetMatchesSpec(lenLimit, curMatch, MF_PARAMS(p),
 910 -    distances, 2) - (distances));
 911 -  MOVE_POS_RET
 912 -}
 913 -
 914 -static void Bt2_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
 915 -{
 916 -  do
 917 -  {
 918 -    SKIP_HEADER(2)
 919 -    HASH2_CALC;
 920 -    curMatch = p->hash[hashValue];
 921 -    p->hash[hashValue] = p->pos;
 922 -    SKIP_FOOTER
 923 -  }
 924 -  while (--num != 0);
 925 -}
 926 -
 927 -void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
 928 -{
 929 -  do
 930 -  {
 931 -    SKIP_HEADER(3)
 932 -    HASH_ZIP_CALC;
 933 -    curMatch = p->hash[hashValue];
 934 -    p->hash[hashValue] = p->pos;
 935 -    SKIP_FOOTER
 936 -  }
 937 -  while (--num != 0);
 938 -}
 939 -
 940 -static void Bt3_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
 941 -{
 942 -  do
 943 -  {
 944 -    UInt32 hash2Value;
 945 -    SKIP_HEADER(3)
 946 -    HASH3_CALC;
 947 -    curMatch = p->hash[kFix3HashSize + hashValue];
 948 -    p->hash[hash2Value] =
 949 -    p->hash[kFix3HashSize + hashValue] = p->pos;
 950 -    SKIP_FOOTER
 951 -  }
 952 -  while (--num != 0);
 953 -}
 954 -
 955  static void Bt4_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
 956  {
 957    do
 958 @@ -701,61 +511,12 @@ static void Bt4_MatchFinder_Skip(CMatchF
 959    while (--num != 0);
 960  }
 961
 962 -static void Hc4_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
 963 -{
 964 -  do
 965 -  {
 966 -    UInt32 hash2Value, hash3Value;
 967 -    SKIP_HEADER(4)
 968 -    HASH4_CALC;
 969 -    curMatch = p->hash[kFix4HashSize + hashValue];
 970 -    p->hash[                hash2Value] =
 971 -    p->hash[kFix3HashSize + hash3Value] =
 972 -    p->hash[kFix4HashSize + hashValue] = p->pos;
 973 -    p->son[p->cyclicBufferPos] = curMatch;
 974 -    MOVE_POS
 975 -  }
 976 -  while (--num != 0);
 977 -}
 978 -
 979 -void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
 980 -{
 981 -  do
 982 -  {
 983 -    SKIP_HEADER(3)
 984 -    HASH_ZIP_CALC;
 985 -    curMatch = p->hash[hashValue];
 986 -    p->hash[hashValue] = p->pos;
 987 -    p->son[p->cyclicBufferPos] = curMatch;
 988 -    MOVE_POS
 989 -  }
 990 -  while (--num != 0);
 991 -}
 992 -
 993  void MatchFinder_CreateVTable(CMatchFinder *p, IMatchFinder *vTable)
 994  {
 995    vTable->Init = (Mf_Init_Func)MatchFinder_Init;
 996    vTable->GetIndexByte = (Mf_GetIndexByte_Func)MatchFinder_GetIndexByte;
 997    vTable->GetNumAvailableBytes = (Mf_GetNumAvailableBytes_Func)MatchFinder_GetNumAvailableBytes;
 998    vTable->GetPointerToCurrentPos = (Mf_GetPointerToCurrentPos_Func)MatchFinder_GetPointerToCurrentPos;
 999 -  if (!p->btMode)
1000 -  {
1001 -    vTable->GetMatches = (Mf_GetMatches_Func)Hc4_MatchFinder_GetMatches;
1002 -    vTable->Skip = (Mf_Skip_Func)Hc4_MatchFinder_Skip;
1003 -  }
1004 -  else if (p->numHashBytes == 2)
1005 -  {
1006 -    vTable->GetMatches = (Mf_GetMatches_Func)Bt2_MatchFinder_GetMatches;
1007 -    vTable->Skip = (Mf_Skip_Func)Bt2_MatchFinder_Skip;
1008 -  }
1009 -  else if (p->numHashBytes == 3)
1010 -  {
1011 -    vTable->GetMatches = (Mf_GetMatches_Func)Bt3_MatchFinder_GetMatches;
1012 -    vTable->Skip = (Mf_Skip_Func)Bt3_MatchFinder_Skip;
1013 -  }
1014 -  else
1015 -  {
1016 -    vTable->GetMatches = (Mf_GetMatches_Func)Bt4_MatchFinder_GetMatches;
1017 -    vTable->Skip = (Mf_Skip_Func)Bt4_MatchFinder_Skip;
1018 -  }
1019 +  vTable->GetMatches = (Mf_GetMatches_Func)Bt4_MatchFinder_GetMatches;
1020 +  vTable->Skip = (Mf_Skip_Func)Bt4_MatchFinder_Skip;
1021  }