rpm-lzma.patch

   1 --- /dev/null   2005-12-16 15:50:59.000000000 +0100
   2 +++ rpm-4.4.5/rpmio/LzmaDecode.c        2006-04-23 13:07:24.000000000 +0200
   3 @@ -0,0 +1,588 @@
   4 +/*
   5 +  LzmaDecode.c
   6 +  LZMA Decoder (optimized for Speed version)
   7 +
   8 +  LZMA SDK 4.22 Copyright (c) 1999-2005 Igor Pavlov (2005-06-10)
   9 +  http://www.7-zip.org/
  10 +
  11 +  LZMA SDK is licensed under two licenses:
  12 +  1) GNU Lesser General Public License (GNU LGPL)
  13 +  2) Common Public License (CPL)
  14 +  It means that you can select one of these two licenses and
  15 +  follow rules of that license.
  16 +
  17 +  SPECIAL EXCEPTION:
  18 +  Igor Pavlov, as the author of this Code, expressly permits you to
  19 +  statically or dynamically link your Code (or bind by name) to the
  20 +  interfaces of this file without subjecting your linked Code to the
  21 +  terms of the CPL or GNU LGPL. Any modifications or additions
  22 +  to this file, however, are subject to the LGPL or CPL terms.
  23 +*/
  24 +
  25 +#include "LzmaDecode.h"
  26 +
  27 +#ifndef Byte
  28 +#define Byte unsigned char
  29 +#endif
  30 +
  31 +#define kNumTopBits 24
  32 +#define kTopValue ((UInt32)1 << kNumTopBits)
  33 +
  34 +#define kNumBitModelTotalBits 11
  35 +#define kBitModelTotal (1 << kNumBitModelTotalBits)
  36 +#define kNumMoveBits 5
  37 +
  38 +#define RC_READ_BYTE (*Buffer++)
  39 +
  40 +#define RC_INIT2 Code = 0; Range = 0xFFFFFFFF; \
  41 +  { int i; for(i = 0; i < 5; i++) { RC_TEST; Code = (Code << 8) | RC_READ_BYTE; }}
  42 +
  43 +#ifdef _LZMA_IN_CB
  44 +
  45 +#define RC_TEST { if (Buffer == BufferLim) \
  46 +  { SizeT size; int result = InCallback->Read(InCallback, &Buffer, &size); if (result != LZMA_RESULT_OK) return result; \
  47 +  BufferLim = Buffer + size; if (size == 0) return LZMA_RESULT_DATA_ERROR; }}
  48 +
  49 +#define RC_INIT Buffer = BufferLim = 0; RC_INIT2
  50 +
  51 +#else
  52 +
  53 +#define RC_TEST { if (Buffer == BufferLim) return LZMA_RESULT_DATA_ERROR; }
  54 +
  55 +#define RC_INIT(buffer, bufferSize) Buffer = buffer; BufferLim = buffer + bufferSize; RC_INIT2
  56 +
  57 +#endif
  58 +
  59 +#define RC_NORMALIZE if (Range < kTopValue) { RC_TEST; Range <<= 8; Code = (Code << 8) | RC_READ_BYTE; }
  60 +
  61 +#define IfBit0(p) RC_NORMALIZE; bound = (Range >> kNumBitModelTotalBits) * *(p); if (Code < bound)
  62 +#define UpdateBit0(p) Range = bound; *(p) += (kBitModelTotal - *(p)) >> kNumMoveBits;
  63 +#define UpdateBit1(p) Range -= bound; Code -= bound; *(p) -= (*(p)) >> kNumMoveBits;
  64 +
  65 +#define RC_GET_BIT2(p, mi, A0, A1) IfBit0(p) \
  66 +  { UpdateBit0(p); mi <<= 1; A0; } else \
  67 +  { UpdateBit1(p); mi = (mi + mi) + 1; A1; }
  68 +
  69 +#define RC_GET_BIT(p, mi) RC_GET_BIT2(p, mi, ; , ;)
  70 +
  71 +#define RangeDecoderBitTreeDecode(probs, numLevels, res) \
  72 +  { int i = numLevels; res = 1; \
  73 +  do { CProb *p = probs + res; RC_GET_BIT(p, res) } while(--i != 0); \
  74 +  res -= (1 << numLevels); }
  75 +
  76 +
  77 +#define kNumPosBitsMax 4
  78 +#define kNumPosStatesMax (1 << kNumPosBitsMax)
  79 +
  80 +#define kLenNumLowBits 3
  81 +#define kLenNumLowSymbols (1 << kLenNumLowBits)
  82 +#define kLenNumMidBits 3
  83 +#define kLenNumMidSymbols (1 << kLenNumMidBits)
  84 +#define kLenNumHighBits 8
  85 +#define kLenNumHighSymbols (1 << kLenNumHighBits)
  86 +
  87 +#define LenChoice 0
  88 +#define LenChoice2 (LenChoice + 1)
  89 +#define LenLow (LenChoice2 + 1)
  90 +#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits))
  91 +#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits))
  92 +#define kNumLenProbs (LenHigh + kLenNumHighSymbols)
  93 +
  94 +
  95 +#define kNumStates 12
  96 +#define kNumLitStates 7
  97 +
  98 +#define kStartPosModelIndex 4
  99 +#define kEndPosModelIndex 14
 100 +#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
 101 +
 102 +#define kNumPosSlotBits 6
 103 +#define kNumLenToPosStates 4
 104 +
 105 +#define kNumAlignBits 4
 106 +#define kAlignTableSize (1 << kNumAlignBits)
 107 +
 108 +#define kMatchMinLen 2
 109 +
 110 +#define IsMatch 0
 111 +#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax))
 112 +#define IsRepG0 (IsRep + kNumStates)
 113 +#define IsRepG1 (IsRepG0 + kNumStates)
 114 +#define IsRepG2 (IsRepG1 + kNumStates)
 115 +#define IsRep0Long (IsRepG2 + kNumStates)
 116 +#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax))
 117 +#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))
 118 +#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex)
 119 +#define LenCoder (Align + kAlignTableSize)
 120 +#define RepLenCoder (LenCoder + kNumLenProbs)
 121 +#define Literal (RepLenCoder + kNumLenProbs)
 122 +
 123 +#if Literal != LZMA_BASE_SIZE
 124 +StopCompilingDueBUG
 125 +#endif
 126 +
 127 +int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size)
 128 +{
 129 +  unsigned char prop0;
 130 +  if (size < LZMA_PROPERTIES_SIZE)
 131 +    return LZMA_RESULT_DATA_ERROR;
 132 +  prop0 = propsData[0];
 133 +  if (prop0 >= (9 * 5 * 5))
 134 +    return LZMA_RESULT_DATA_ERROR;
 135 +  {
 136 +    for (propsRes->pb = 0; prop0 >= (9 * 5); propsRes->pb++, prop0 -= (9 * 5));
 137 +    for (propsRes->lp = 0; prop0 >= 9; propsRes->lp++, prop0 -= 9);
 138 +    propsRes->lc = prop0;
 139 +    /*
 140 +    unsigned char remainder = (unsigned char)(prop0 / 9);
 141 +    propsRes->lc = prop0 % 9;
 142 +    propsRes->pb = remainder / 5;
 143 +    propsRes->lp = remainder % 5;
 144 +    */
 145 +  }
 146 +
 147 +  #ifdef _LZMA_OUT_READ
 148 +  {
 149 +    int i;
 150 +    propsRes->DictionarySize = 0;
 151 +    for (i = 0; i < 4; i++)
 152 +      propsRes->DictionarySize += (UInt32)(propsData[1 + i]) << (i * 8);
 153 +    if (propsRes->DictionarySize == 0)
 154 +      propsRes->DictionarySize = 1;
 155 +  }
 156 +  #endif
 157 +  return LZMA_RESULT_OK;
 158 +}
 159 +
 160 +#define kLzmaStreamWasFinishedId (-1)
 161 +
 162 +int LzmaDecode(CLzmaDecoderState *vs,
 163 +    #ifdef _LZMA_IN_CB
 164 +    ILzmaInCallback *InCallback,
 165 +    #else
 166 +    const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed,
 167 +    #endif
 168 +    unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed)
 169 +{
 170 +  CProb *p = vs->Probs;
 171 +  SizeT nowPos = 0;
 172 +  Byte previousByte = 0;
 173 +  UInt32 posStateMask = (1 << (vs->Properties.pb)) - 1;
 174 +  UInt32 literalPosMask = (1 << (vs->Properties.lp)) - 1;
 175 +  int lc = vs->Properties.lc;
 176 +
 177 +  #ifdef _LZMA_OUT_READ
 178 +
 179 +  UInt32 Range = vs->Range;
 180 +  UInt32 Code = vs->Code;
 181 +  #ifdef _LZMA_IN_CB
 182 +  const Byte *Buffer = vs->Buffer;
 183 +  const Byte *BufferLim = vs->BufferLim;
 184 +  #else
 185 +  const Byte *Buffer = inStream;
 186 +  const Byte *BufferLim = inStream + inSize;
 187 +  #endif
 188 +  int state = vs->State;
 189 +  UInt32 rep0 = vs->Reps[0], rep1 = vs->Reps[1], rep2 = vs->Reps[2], rep3 = vs->Reps[3];
 190 +  int len = vs->RemainLen;
 191 +  UInt32 globalPos = vs->GlobalPos;
 192 +  UInt32 distanceLimit = vs->DistanceLimit;
 193 +
 194 +  Byte *dictionary = vs->Dictionary;
 195 +  UInt32 dictionarySize = vs->Properties.DictionarySize;
 196 +  UInt32 dictionaryPos = vs->DictionaryPos;
 197 +
 198 +  Byte tempDictionary[4];
 199 +
 200 +  #ifndef _LZMA_IN_CB
 201 +  *inSizeProcessed = 0;
 202 +  #endif
 203 +  *outSizeProcessed = 0;
 204 +  if (len == kLzmaStreamWasFinishedId)
 205 +    return LZMA_RESULT_OK;
 206 +
 207 +  if (dictionarySize == 0)
 208 +  {
 209 +    dictionary = tempDictionary;
 210 +    dictionarySize = 1;
 211 +    tempDictionary[0] = vs->TempDictionary[0];
 212 +  }
 213 +
 214 +  if (len == kLzmaNeedInitId)
 215 +  {
 216 +    {
 217 +      UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp));
 218 +      UInt32 i;
 219 +      for (i = 0; i < numProbs; i++)
 220 +        p[i] = kBitModelTotal >> 1;
 221 +      rep0 = rep1 = rep2 = rep3 = 1;
 222 +      state = 0;
 223 +      globalPos = 0;
 224 +      distanceLimit = 0;
 225 +      dictionaryPos = 0;
 226 +      dictionary[dictionarySize - 1] = 0;
 227 +      #ifdef _LZMA_IN_CB
 228 +      RC_INIT;
 229 +      #else
 230 +      RC_INIT(inStream, inSize);
 231 +      #endif
 232 +    }
 233 +    len = 0;
 234 +  }
 235 +  while(len != 0 && nowPos < outSize)
 236 +  {
 237 +    UInt32 pos = dictionaryPos - rep0;
 238 +    if (pos >= dictionarySize)
 239 +      pos += dictionarySize;
 240 +    outStream[nowPos++] = dictionary[dictionaryPos] = dictionary[pos];
 241 +    if (++dictionaryPos == dictionarySize)
 242 +      dictionaryPos = 0;
 243 +    len--;
 244 +  }
 245 +  if (dictionaryPos == 0)
 246 +    previousByte = dictionary[dictionarySize - 1];
 247 +  else
 248 +    previousByte = dictionary[dictionaryPos - 1];
 249 +
 250 +  #else /* if !_LZMA_OUT_READ */
 251 +
 252 +  int state = 0;
 253 +  UInt32 rep0 = 1, rep1 = 1, rep2 = 1, rep3 = 1;
 254 +  int len = 0;
 255 +  const Byte *Buffer;
 256 +  const Byte *BufferLim;
 257 +  UInt32 Range;
 258 +  UInt32 Code;
 259 +
 260 +  #ifndef _LZMA_IN_CB
 261 +  *inSizeProcessed = 0;
 262 +  #endif
 263 +  *outSizeProcessed = 0;
 264 +
 265 +  {
 266 +    UInt32 i;
 267 +    UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp));
 268 +    for (i = 0; i < numProbs; i++)
 269 +      p[i] = kBitModelTotal >> 1;
 270 +  }
 271 +
 272 +  #ifdef _LZMA_IN_CB
 273 +  RC_INIT;
 274 +  #else
 275 +  RC_INIT(inStream, inSize);
 276 +  #endif
 277 +
 278 +  #endif /* _LZMA_OUT_READ */
 279 +
 280 +  while(nowPos < outSize)
 281 +  {
 282 +    CProb *prob;
 283 +    UInt32 bound;
 284 +    int posState = (int)(
 285 +        (nowPos
 286 +        #ifdef _LZMA_OUT_READ
 287 +        + globalPos
 288 +        #endif
 289 +        )
 290 +        & posStateMask);
 291 +
 292 +    prob = p + IsMatch + (state << kNumPosBitsMax) + posState;
 293 +    IfBit0(prob)
 294 +    {
 295 +      int symbol = 1;
 296 +      UpdateBit0(prob)
 297 +      prob = p + Literal + (LZMA_LIT_SIZE *
 298 +        (((
 299 +        (nowPos
 300 +        #ifdef _LZMA_OUT_READ
 301 +        + globalPos
 302 +        #endif
 303 +        )
 304 +        & literalPosMask) << lc) + (previousByte >> (8 - lc))));
 305 +
 306 +      if (state >= kNumLitStates)
 307 +      {
 308 +        int matchByte;
 309 +        #ifdef _LZMA_OUT_READ
 310 +        UInt32 pos = dictionaryPos - rep0;
 311 +        if (pos >= dictionarySize)
 312 +          pos += dictionarySize;
 313 +        matchByte = dictionary[pos];
 314 +        #else
 315 +        matchByte = outStream[nowPos - rep0];
 316 +        #endif
 317 +        do
 318 +        {
 319 +          int bit;
 320 +          CProb *probLit;
 321 +          matchByte <<= 1;
 322 +          bit = (matchByte & 0x100);
 323 +          probLit = prob + 0x100 + bit + symbol;
 324 +          RC_GET_BIT2(probLit, symbol, if (bit != 0) break, if (bit == 0) break)
 325 +        }
 326 +        while (symbol < 0x100);
 327 +      }
 328 +      while (symbol < 0x100)
 329 +      {
 330 +        CProb *probLit = prob + symbol;
 331 +        RC_GET_BIT(probLit, symbol)
 332 +      }
 333 +      previousByte = (Byte)symbol;
 334 +
 335 +      outStream[nowPos++] = previousByte;
 336 +      #ifdef _LZMA_OUT_READ
 337 +      if (distanceLimit < dictionarySize)
 338 +        distanceLimit++;
 339 +
 340 +      dictionary[dictionaryPos] = previousByte;
 341 +      if (++dictionaryPos == dictionarySize)
 342 +        dictionaryPos = 0;
 343 +      #endif
 344 +      if (state < 4) state = 0;
 345 +      else if (state < 10) state -= 3;
 346 +      else state -= 6;
 347 +    }
 348 +    else
 349 +    {
 350 +      UpdateBit1(prob);
 351 +      prob = p + IsRep + state;
 352 +      IfBit0(prob)
 353 +      {
 354 +        UpdateBit0(prob);
 355 +        rep3 = rep2;
 356 +        rep2 = rep1;
 357 +        rep1 = rep0;
 358 +        state = state < kNumLitStates ? 0 : 3;
 359 +        prob = p + LenCoder;
 360 +      }
 361 +      else
 362 +      {
 363 +        UpdateBit1(prob);
 364 +        prob = p + IsRepG0 + state;
 365 +        IfBit0(prob)
 366 +        {
 367 +          UpdateBit0(prob);
 368 +          prob = p + IsRep0Long + (state << kNumPosBitsMax) + posState;
 369 +          IfBit0(prob)
 370 +          {
 371 +            #ifdef _LZMA_OUT_READ
 372 +            UInt32 pos;
 373 +            #endif
 374 +            UpdateBit0(prob);
 375 +
 376 +            #ifdef _LZMA_OUT_READ
 377 +            if (distanceLimit == 0)
 378 +            #else
 379 +            if (nowPos == 0)
 380 +            #endif
 381 +              return LZMA_RESULT_DATA_ERROR;
 382 +
 383 +            state = state < kNumLitStates ? 9 : 11;
 384 +            #ifdef _LZMA_OUT_READ
 385 +            pos = dictionaryPos - rep0;
 386 +            if (pos >= dictionarySize)
 387 +              pos += dictionarySize;
 388 +            previousByte = dictionary[pos];
 389 +            dictionary[dictionaryPos] = previousByte;
 390 +            if (++dictionaryPos == dictionarySize)
 391 +              dictionaryPos = 0;
 392 +            #else
 393 +            previousByte = outStream[nowPos - rep0];
 394 +            #endif
 395 +            outStream[nowPos++] = previousByte;
 396 +            #ifdef _LZMA_OUT_READ
 397 +            if (distanceLimit < dictionarySize)
 398 +              distanceLimit++;
 399 +            #endif
 400 +
 401 +            continue;
 402 +          }
 403 +          else
 404 +          {
 405 +            UpdateBit1(prob);
 406 +          }
 407 +        }
 408 +        else
 409 +        {
 410 +          UInt32 distance;
 411 +          UpdateBit1(prob);
 412 +          prob = p + IsRepG1 + state;
 413 +          IfBit0(prob)
 414 +          {
 415 +            UpdateBit0(prob);
 416 +            distance = rep1;
 417 +          }
 418 +          else
 419 +          {
 420 +            UpdateBit1(prob);
 421 +            prob = p + IsRepG2 + state;
 422 +            IfBit0(prob)
 423 +            {
 424 +              UpdateBit0(prob);
 425 +              distance = rep2;
 426 +            }
 427 +            else
 428 +            {
 429 +              UpdateBit1(prob);
 430 +              distance = rep3;
 431 +              rep3 = rep2;
 432 +            }
 433 +            rep2 = rep1;
 434 +          }
 435 +          rep1 = rep0;
 436 +          rep0 = distance;
 437 +        }
 438 +        state = state < kNumLitStates ? 8 : 11;
 439 +        prob = p + RepLenCoder;
 440 +      }
 441 +      {
 442 +        int numBits, offset;
 443 +        CProb *probLen = prob + LenChoice;
 444 +        IfBit0(probLen)
 445 +        {
 446 +          UpdateBit0(probLen);
 447 +          probLen = prob + LenLow + (posState << kLenNumLowBits);
 448 +          offset = 0;
 449 +          numBits = kLenNumLowBits;
 450 +        }
 451 +        else
 452 +        {
 453 +          UpdateBit1(probLen);
 454 +          probLen = prob + LenChoice2;
 455 +          IfBit0(probLen)
 456 +          {
 457 +            UpdateBit0(probLen);
 458 +            probLen = prob + LenMid + (posState << kLenNumMidBits);
 459 +            offset = kLenNumLowSymbols;
 460 +            numBits = kLenNumMidBits;
 461 +          }
 462 +          else
 463 +          {
 464 +            UpdateBit1(probLen);
 465 +            probLen = prob + LenHigh;
 466 +            offset = kLenNumLowSymbols + kLenNumMidSymbols;
 467 +            numBits = kLenNumHighBits;
 468 +          }
 469 +        }
 470 +        RangeDecoderBitTreeDecode(probLen, numBits, len);
 471 +        len += offset;
 472 +      }
 473 +
 474 +      if (state < 4)
 475 +      {
 476 +        int posSlot;
 477 +        state += kNumLitStates;
 478 +        prob = p + PosSlot +
 479 +            ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) <<
 480 +            kNumPosSlotBits);
 481 +        RangeDecoderBitTreeDecode(prob, kNumPosSlotBits, posSlot);
 482 +        if (posSlot >= kStartPosModelIndex)
 483 +        {
 484 +          int numDirectBits = ((posSlot >> 1) - 1);
 485 +          rep0 = (2 | ((UInt32)posSlot & 1));
 486 +          if (posSlot < kEndPosModelIndex)
 487 +          {
 488 +            rep0 <<= numDirectBits;
 489 +            prob = p + SpecPos + rep0 - posSlot - 1;
 490 +          }
 491 +          else
 492 +          {
 493 +            numDirectBits -= kNumAlignBits;
 494 +            do
 495 +            {
 496 +              RC_NORMALIZE
 497 +              Range >>= 1;
 498 +              rep0 <<= 1;
 499 +              if (Code >= Range)
 500 +              {
 501 +                Code -= Range;
 502 +                rep0 |= 1;
 503 +              }
 504 +            }
 505 +            while (--numDirectBits != 0);
 506 +            prob = p + Align;
 507 +            rep0 <<= kNumAlignBits;
 508 +            numDirectBits = kNumAlignBits;
 509 +          }
 510 +          {
 511 +            int i = 1;
 512 +            int mi = 1;
 513 +            do
 514 +            {
 515 +              CProb *prob3 = prob + mi;
 516 +              RC_GET_BIT2(prob3, mi, ; , rep0 |= i);
 517 +              i <<= 1;
 518 +            }
 519 +            while(--numDirectBits != 0);
 520 +          }
 521 +        }
 522 +        else
 523 +          rep0 = posSlot;
 524 +        if (++rep0 == (UInt32)(0))
 525 +        {
 526 +          /* it's for stream version */
 527 +          len = kLzmaStreamWasFinishedId;
 528 +          break;
 529 +        }
 530 +      }
 531 +
 532 +      len += kMatchMinLen;
 533 +      #ifdef _LZMA_OUT_READ
 534 +      if (rep0 > distanceLimit)
 535 +      #else
 536 +      if (rep0 > nowPos)
 537 +      #endif
 538 +        return LZMA_RESULT_DATA_ERROR;
 539 +
 540 +      #ifdef _LZMA_OUT_READ
 541 +      if (dictionarySize - distanceLimit > (UInt32)len)
 542 +        distanceLimit += len;
 543 +      else
 544 +        distanceLimit = dictionarySize;
 545 +      #endif
 546 +
 547 +      do
 548 +      {
 549 +        #ifdef _LZMA_OUT_READ
 550 +        UInt32 pos = dictionaryPos - rep0;
 551 +        if (pos >= dictionarySize)
 552 +          pos += dictionarySize;
 553 +        previousByte = dictionary[pos];
 554 +        dictionary[dictionaryPos] = previousByte;
 555 +        if (++dictionaryPos == dictionarySize)
 556 +          dictionaryPos = 0;
 557 +        #else
 558 +        previousByte = outStream[nowPos - rep0];
 559 +        #endif
 560 +        len--;
 561 +        outStream[nowPos++] = previousByte;
 562 +      }
 563 +      while(len != 0 && nowPos < outSize);
 564 +    }
 565 +  }
 566 +  RC_NORMALIZE;
 567 +
 568 +  #ifdef _LZMA_OUT_READ
 569 +  vs->Range = Range;
 570 +  vs->Code = Code;
 571 +  vs->DictionaryPos = dictionaryPos;
 572 +  vs->GlobalPos = globalPos + (UInt32)nowPos;
 573 +  vs->DistanceLimit = distanceLimit;
 574 +  vs->Reps[0] = rep0;
 575 +  vs->Reps[1] = rep1;
 576 +  vs->Reps[2] = rep2;
 577 +  vs->Reps[3] = rep3;
 578 +  vs->State = state;
 579 +  vs->RemainLen = len;
 580 +  vs->TempDictionary[0] = tempDictionary[0];
 581 +  #endif
 582 +
 583 +  #ifdef _LZMA_IN_CB
 584 +  vs->Buffer = Buffer;
 585 +  vs->BufferLim = BufferLim;
 586 +  #else
 587 +  *inSizeProcessed = (SizeT)(Buffer - inStream);
 588 +  #endif
 589 +  *outSizeProcessed = nowPos;
 590 +  return LZMA_RESULT_OK;
 591 +}
 592 --- /dev/null   2005-12-16 15:50:59.000000000 +0100
 593 +++ rpm-4.4.5/rpmio/LzmaDecode.h        2006-04-23 13:25:41.000000000 +0200
 594 @@ -0,0 +1,131 @@
 595 +/*
 596 +  LzmaDecode.h
 597 +  LZMA Decoder interface
 598 +
 599 +  LZMA SDK 4.21 Copyright (c) 1999-2005 Igor Pavlov (2005-06-08)
 600 +  http://www.7-zip.org/
 601 +
 602 +  LZMA SDK is licensed under two licenses:
 603 +  1) GNU Lesser General Public License (GNU LGPL)
 604 +  2) Common Public License (CPL)
 605 +  It means that you can select one of these two licenses and
 606 +  follow rules of that license.
 607 +
 608 +  SPECIAL EXCEPTION:
 609 +  Igor Pavlov, as the author of this code, expressly permits you to
 610 +  statically or dynamically link your code (or bind by name) to the
 611 +  interfaces of this file without subjecting your linked code to the
 612 +  terms of the CPL or GNU LGPL. Any modifications or additions
 613 +  to this file, however, are subject to the LGPL or CPL terms.
 614 +*/
 615 +
 616 +#ifndef __LZMADECODE_H
 617 +#define __LZMADECODE_H
 618 +
 619 +#define _LZMA_IN_CB
 620 +/* Use callback for input data */
 621 +
 622 +#define _LZMA_OUT_READ
 623 +/* Use read function for output data */
 624 +
 625 +/* #define _LZMA_PROB32 */
 626 +/* It can increase speed on some 32-bit CPUs,
 627 +   but memory usage will be doubled in that case */
 628 +
 629 +/* #define _LZMA_LOC_OPT */
 630 +/* Enable local speed optimizations inside code */
 631 +
 632 +/* #define _LZMA_SYSTEM_SIZE_T */
 633 +/* Use system's size_t. You can use it to enable 64-bit sizes supporting*/
 634 +
 635 +#ifndef UInt32
 636 +#ifdef _LZMA_UINT32_IS_ULONG
 637 +#define UInt32 unsigned long
 638 +#else
 639 +#define UInt32 unsigned int
 640 +#endif
 641 +#endif
 642 +
 643 +#ifndef SizeT
 644 +#ifdef _LZMA_SYSTEM_SIZE_T
 645 +#include <stddef.h>
 646 +#define SizeT size_t
 647 +#else
 648 +#define SizeT UInt32
 649 +#endif
 650 +#endif
 651 +
 652 +#ifdef _LZMA_PROB32
 653 +#define CProb UInt32
 654 +#else
 655 +#define CProb unsigned short
 656 +#endif
 657 +
 658 +#define LZMA_RESULT_OK 0
 659 +#define LZMA_RESULT_DATA_ERROR 1
 660 +
 661 +#ifdef _LZMA_IN_CB
 662 +typedef struct _ILzmaInCallback
 663 +{
 664 +  int (*Read)(void *object, const unsigned char **buffer, SizeT *bufferSize);
 665 +} ILzmaInCallback;
 666 +#endif
 667 +
 668 +#define LZMA_BASE_SIZE 1846
 669 +#define LZMA_LIT_SIZE 768
 670 +
 671 +#define LZMA_PROPERTIES_SIZE 5
 672 +
 673 +typedef struct _CLzmaProperties
 674 +{
 675 +  int lc;
 676 +  int lp;
 677 +  int pb;
 678 +  #ifdef _LZMA_OUT_READ
 679 +  UInt32 DictionarySize;
 680 +  #endif
 681 +}CLzmaProperties;
 682 +
 683 +int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size);
 684 +
 685 +#define LzmaGetNumProbs(Properties) (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((Properties)->lc + (Properties)->lp)))
 686 +
 687 +#define kLzmaNeedInitId (-2)
 688 +
 689 +typedef struct _CLzmaDecoderState
 690 +{
 691 +  CLzmaProperties Properties;
 692 +  CProb *Probs;
 693 +
 694 +  #ifdef _LZMA_IN_CB
 695 +  const unsigned char *Buffer;
 696 +  const unsigned char *BufferLim;
 697 +  #endif
 698 +
 699 +  #ifdef _LZMA_OUT_READ
 700 +  unsigned char *Dictionary;
 701 +  UInt32 Range;
 702 +  UInt32 Code;
 703 +  UInt32 DictionaryPos;
 704 +  UInt32 GlobalPos;
 705 +  UInt32 DistanceLimit;
 706 +  UInt32 Reps[4];
 707 +  int State;
 708 +  int RemainLen;
 709 +  unsigned char TempDictionary[4];
 710 +  #endif
 711 +} CLzmaDecoderState;
 712 +
 713 +#ifdef _LZMA_OUT_READ
 714 +#define LzmaDecoderInit(vs) { (vs)->RemainLen = kLzmaNeedInitId; }
 715 +#endif
 716 +
 717 +int LzmaDecode(CLzmaDecoderState *vs,
 718 +    #ifdef _LZMA_IN_CB
 719 +    ILzmaInCallback *inCallback,
 720 +    #else
 721 +    const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed,
 722 +    #endif
 723 +    unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed);
 724 +
 725 +#endif