Home | History | Annotate | Download | only in C

Lines Matching refs:opt

279   COptimal opt[kNumOpts];

893   UInt32 posMem = p->opt[cur].posPrev;

894   UInt32 backMem = p->opt[cur].backPrev;

898     if (p->opt[cur].prev1IsChar)

900       MakeAsChar(&p->opt[posMem])

901       p->opt[posMem].posPrev = posMem - 1;

902       if (p->opt[cur].prev2)

904         p->opt[posMem - 1].prev1IsChar = False;

905         p->opt[posMem - 1].posPrev = p->opt[cur].posPrev2;

906         p->opt[posMem - 1].backPrev = p->opt[cur].backPrev2;

913       backMem = p->opt[posPrev].backPrev;

914       posMem = p->opt[posPrev].posPrev;

916       p->opt[posPrev].backPrev = backCur;

917       p->opt[posPrev].posPrev = cur;

922   *backRes = p->opt[0].backPrev;

923   p->optimumCurrentIndex  = p->opt[0].posPrev;

939     const COptimal *opt = &p->opt[p->optimumCurrentIndex];

940     UInt32 lenRes = opt->posPrev - p->optimumCurrentIndex;

941     *backRes = opt->backPrev;

942     p->optimumCurrentIndex = opt->posPrev;

1007   p->opt[0].state = (CState)p->state;

1013     p->opt[1].price = GET_PRICE_0(p->isMatch[p->state][posState]) +

1019   MakeAsChar(&p->opt[1]);

1027     if (shortRepPrice < p->opt[1].price)

1029       p->opt[1].price = shortRepPrice;

1030       MakeAsShortRep(&p->opt[1]);

1037     *backRes = p->opt[1].backPrev;

1041   p->opt[1].posPrev = 0;

1043     p->opt[0].backs[i] = reps[i];

1047     p->opt[len--].price = kInfinityPrice;

1060       COptimal *opt = &p->opt[repLen];

1061       if (curAndLenPrice < opt->price)

1063         opt->price = curAndLenPrice;

1064         opt->posPrev = 0;

1065         opt->backPrev = i;

1066         opt->prev1IsChar = False;

1082       COptimal *opt;

1095       opt = &p->opt[len];

1096       if (curAndLenPrice < opt->price)

1098         opt->price = curAndLenPrice;

1099         opt->posPrev = 0;

1100         opt->backPrev = distance + LZMA_NUM_REPS;

1101         opt->prev1IsChar = False;

1120       printf("\nprice[%4X] = %d", position - cur + i, p->opt[i].price);

1146     curOpt = &p->opt[cur];

1153         state = p->opt[curOpt->posPrev2].state;

1160         state = p->opt[posPrev].state;

1164       state = p->opt[posPrev].state;

1190       prevOpt = &p->opt[posPrev];

1232     nextOpt = &p->opt[cur + 1];

1289           COptimal *opt;

1292             p->opt[++lenEnd].price = kInfinityPrice;

1294           opt = &p->opt[offset];

1295           if (curAndLenPrice < opt->price)

1297             opt->price = curAndLenPrice;

1298             opt->posPrev = cur + 1;

1299             opt->backPrev = 0;

1300             opt->prev1IsChar = True;

1301             opt->prev2 = False;

1320         p->opt[++lenEnd].price = kInfinityPrice;

1326         COptimal *opt = &p->opt[cur + lenTest];

1327         if (curAndLenPrice < opt->price)

1329           opt->price = curAndLenPrice;

1330           opt->posPrev = cur;

1331           opt->backPrev = repIndex;

1332           opt->prev1IsChar = False;

1368               COptimal *opt;

1371                 p->opt[++lenEnd].price = kInfinityPrice;

1373               opt = &p->opt[offset];

1374               if (curAndLenPrice < opt->price)

1376                 opt->price = curAndLenPrice;

1377                 opt->posPrev = cur + lenTest + 1;

1378                 opt->backPrev = 0;

1379                 opt->prev1IsChar = True;

1380                 opt->prev2 = True;

1381                 opt->posPrev2 = cur;

1382                 opt->backPrev2 = repIndex;

1403         p->opt[++lenEnd].price = kInfinityPrice;

1414         COptimal *opt;

1420         opt = &p->opt[cur + lenTest];

1421         if (curAndLenPrice < opt->price)

1423           opt->price = curAndLenPrice;

1424           opt->posPrev = cur;

1425           opt->backPrev = curBack + LZMA_NUM_REPS;

1426           opt->prev1IsChar = False;

1458               COptimal *opt;

1460                 p->opt[++lenEnd].price = kInfinityPrice;

1462               opt = &p->opt[offset];

1463               if (curAndLenPrice < opt->price)

1465                 opt->price = curAndLenPrice;

1466                 opt->posPrev = cur + lenTest + 1;

1467                 opt->backPrev = 0;

1468                 opt->prev1IsChar = True;

1469                 opt->prev2 = True;

1470                 opt->posPrev2 = cur;

1471                 opt->backPrev2 = curBack + LZMA_NUM_REPS;