Lines Matching defs:dist

271   UInt32 dist;

450   // we want {len , dist} pairs to be 8-bytes aligned in matches array

1127 #define MakeAs_Lit(p)       { (p)->dist = MARK_LIT; (p)->extra = 0; }

1128 #define MakeAs_ShortRep(p)  { (p)->dist = 0; (p)->extra = 0; }

1129 #define IsShortRep(p)       ((p)->dist == 0)

1174     UInt32 dist = p->opt[cur].dist;

1187         p->opt[wr].dist = dist;

1188         dist = MARK_LIT;

1192         p->opt[wr].dist = 0;

1195         p->opt[wr].dist = MARK_LIT;

1202       p->backRes = dist;

1208     p->opt[wr].dist = dist;

1336         p->backRes = p->opt[1].dist;

1365           opt->dist = (UInt32)i;

1390           UInt32 dist = MATCHES[(size_t)offs + 1];

1394           if (dist < kNumFullDistances)

1395             price += p->distancesPrices[lenToPosState][dist & (kNumFullDistances - 1)];

1399             GetPosSlot2(dist, slot)

1400             price += p->alignPrices[dist & kAlignMask];

1410             opt->dist = dist + LZMA_NUM_REPS;

1515       UInt32 dist = curOpt->dist;

1522           state = (dist < LZMA_NUM_REPS ? kState_RepAfterLit : kState_MatchAfterLit);

1527         if (dist < LZMA_NUM_REPS)

1536       if (dist < LZMA_NUM_REPS)

1538         if (dist == 0)

1549           if (dist == 1)

1558             reps[0] = prevOpt->reps[dist];

1559             reps[3] = prevOpt->reps[dist ^ 1];

1565         reps[0] = (dist - LZMA_NUM_REPS + 1);

1645         || (nextOpt->dist != 0

1708                 opt->dist = 0;

1753               opt->dist = (UInt32)repIndex;

1818                   opt->dist = (UInt32)repIndex;

1845       UInt32 dist;

1857       dist = MATCHES[(size_t)offs + 1];

1859       // if (dist >= kNumFullDistances)

1860       GetPosSlot2(dist, posSlot)

1869           if (dist < kNumFullDistances)

1870             price += p->distancesPrices[lenNorm][dist & (kNumFullDistances - 1)];

1872             price += p->posSlotPrices[lenNorm][posSlot] + p->alignPrices[dist & kAlignMask];

1879             opt->dist = dist + LZMA_NUM_REPS;

1889           const Byte *data2 = data - dist - 1;

1938                 opt->dist = dist + LZMA_NUM_REPS;

1949           dist = MATCHES[(size_t)offs + 1];

1950           // if (dist >= kNumFullDistances)

1951             GetPosSlot2(dist, posSlot)

2424     UInt32 dist;

2440         p->backRes = opt->dist;

2451     dist = p->backRes;

2454     printf("\n pos = %6X, len = %3u  pos = %6u", nowPos32, len, dist);

2457     if (dist == MARK_LIT)

2481       if (dist < LZMA_NUM_REPS)

2486         if (dist == 0)

2506           if (dist == 1)

2509             dist = p->reps[1];

2516             if (dist == 2)

2519               dist = p->reps[2];

2524               dist = p->reps[3];

2530           p->reps[0] = dist;

2554         dist -= LZMA_NUM_REPS;

2558         p->reps[0] = dist + 1;

2561         GetPosSlot(dist, posSlot)

2578         if (dist >= kStartPosModelIndex)

2582           if (dist < kNumFullDistances)

2585             RcTree_ReverseEncode(&p->rc, p->posEncoders + base, footerBits, (unsigned)(dist /* - base */));

2589             UInt32 pos2 = (dist | 0xF) << (32 - footerBits);

2596               p->rc.low += range & (0 - ((dist >> --footerBits) & 1));

2616               bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit)  m = (m << 1) + bit;

2617               bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit)  m = (m << 1) + bit;

2618               bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit)  m = (m << 1) + bit;

2619               bit = dist & 1;             RC_BIT(&p->rc, p->posAlignEncoder + m, bit)