pril 1 (663671), страница 2

Просмтор этого файла доступен только зарегистрированным пользователям. Но у нас супер быстрая регистрация: достаточно только электронной почты!

Текст из файла (страница 2)

CreateBlock4_(block[1], parameters[1], vars[1]);

}

//-----------------------------------------------------------------------------

void CreateBlock5_(Block &block, AlgorithmParameters ¶meters,

cpp_arr_ptr &, unsigned addr)

{

_ASSERT(block.IsEmpty());

SAppropriate appropriate;

appropriate.testContain = true;

appropriate.numShouldContain = 1;

int whatSearch = parameters.counterIsReg ? ES_REG_0 : ES_VARIABLE_0;

appropriate.shouldContain = &whatSearch;

unsigned index;

if (!SearchRandomAppropriateBlock(sizeBlocksArray_05, *sizeBlocks_05,

*blocks_05, appropriate, index))

CkgExcept();

for (unsigned i = 0; i < sizeBlocks_05[index]; i++)

block.Add(blocks_05[index][i]);

unsigned position = 0;

while (SearchSubstitution(block, position))

{

if (!ReplacemenRandomEntity(block.GetRef(position), parameters))

{

int newValue = EO_ERROR;

int b = block[position];

switch (b)

{

case ES_REG_0: _ASSERT(parameters.counterIsReg);

newValue = parameters.counterNumber;

break;

case ES_VARIABLE_0: _ASSERT(!parameters.counterIsReg);

newValue = parameters.counterNumber;

break;

case ES_ADDRESS_0: newValue = static_cast(addr);

break;

default: CkgExcept();

}

block.GetRef(position) = newValue;

}

DEBUG_TEST_BLOCK(block.Get(position));

position++;

}

}

//-----------------------------------------------------------------------------

void CreateBlock5(Block block[], AlgorithmParameters parameters[],

cpp_arr_ptr vars[], unsigned addr1, unsigned addr2)

{

CreateBlock5_(block[0], parameters[0], vars[0], addr1);

CreateBlock5_(block[1], parameters[1], vars[1], addr2);

}

//-----------------------------------------------------------------------------

void CreateBlock6_(Block &block, AlgorithmParameters ¶meters,

cpp_arr_ptr &vars, int deltaTime)

{

_ASSERT(block.IsEmpty());

SAppropriate appropriate;

unsigned index;

if (!SearchRandomAppropriateBlock(sizeBlocksArray_06, *sizeBlocks_06,

*blocks_06, appropriate, index))

CkgExcept();

for (unsigned i = 0; i < sizeBlocks_06[index]; i++)

block.Add(blocks_06[index][i]);

unsigned position = 0;

while (SearchSubstitution(block, position))

{

if (!ReplacemenRandomEntity(block.GetRef(position), parameters))

{

int newValue = EO_ERROR;

int b = block[position];

switch (b)

{

case ES_CONST_0: newValue = deltaTime;

break;

case ES_VARIABLE_0: newValue = ReserveRandomNonUsedVariables(parameters);

vars[static_cast(newValue)] = deltaTime;

break;

default: CkgExcept();

}

block.GetRef(position) = newValue;

}

DEBUG_TEST_BLOCK(block.Get(position));

position++;

}

}

//-----------------------------------------------------------------------------

void CreateBlock6(Block block[], AlgorithmParameters parameters[],

cpp_arr_ptr vars[], unsigned deltaTimeCrypt,

unsigned deltaTimeDecrypt)

{

_ASSERT((deltaTimeCrypt == 0) == (deltaTimeDecrypt == 0));

if (!deltaTimeCrypt)

{

int entity;

unsigned NumNops = LAST_DEFINED_NOP - EO_NOP_0;

entity = CoolRand(NumNops);

entity += EO_NOP_0;

_ASSERT(entity >= EO_NOP_0 && entity <= LAST_DEFINED_NOP);

block->Add(entity);

return;

}

if (deltaTimeCrypt > maxUseTime || deltaTimeCrypt > INT_MAX ||

deltaTimeDecrypt > maxUseTime || deltaTimeDecrypt > INT_MAX)

CkgExcept(_T("Задан слишком большой период времени для возможности использования алгоритма."));

bool invert = CoolRand(2) == 1;

int newDeltaTimeCrypt = invert ? -static_cast(deltaTimeCrypt) :

static_cast(deltaTimeCrypt);

invert = CoolRand(2) == 1;

int newDeltaTimeDecrypt = invert ? -static_cast(deltaTimeDecrypt) :

static_cast(deltaTimeDecrypt);

CreateBlock6_(block[0], parameters[0], vars[0], newDeltaTimeCrypt);

CreateBlock6_(block[1], parameters[1], vars[1], newDeltaTimeDecrypt);

}

//-----------------------------------------------------------------------------

void CreateBlock7_(Block &block, AlgorithmParameters ¶meters,

cpp_arr_ptr &)

{

_ASSERT(block.IsEmpty());

SAppropriate appropriate;

unsigned index;

if (!SearchRandomAppropriateBlock(sizeBlocksArray_07, *sizeBlocks_07,

*blocks_07, appropriate, index))

CkgExcept();

for (unsigned i = 0; i < sizeBlocks_07[index]; i++)

block.Add(blocks_07[index][i]);

unsigned position = 0;

while (SearchSubstitution(block, position))

{

if (!ReplacemenRandomEntity(block.GetRef(position), parameters))

CkgExcept();

DEBUG_TEST_BLOCK(block.Get(position));

position++;

}

}

//-----------------------------------------------------------------------------

void CreateBlock7(Block block[], AlgorithmParameters parameters[],

cpp_arr_ptr vars[])

{

CreateBlock7_(block[0], parameters[0], vars[0]);

CreateBlock7_(block[1], parameters[1], vars[1]);

}

//-----------------------------------------------------------------------------

void GenerateArrayRndDeltas(CkgSimpleContainerArray &deltas,

unsigned num, unsigned freeRegionSize)

{

_ASSERT(num && freeRegionSize);

_ASSERT(deltas.IsEmpty());

unsigned i;

for (i = 0; i < num; i++)

{

unsigned rnd;

#ifdef _DEBUG

unsigned counter = 0;

#endif

do

{

_ASSERT(counter++ < 10);

rnd = CoolRand(freeRegionSize);

if (freeRegionSize <= deltas.GetSize())

CkgExcept(_T("Ошибка в алгоритме генерации UPT-файлов (function GenerateArrayRndDeltas). Обратитесь к разработчику."));

} while(deltas.IndexOf(rnd) != -1);

deltas.Add(rnd);

}

deltas.Add(freeRegionSize);

for (i = 0; i < deltas.GetSize() - 1; i++)

for (unsigned j = i + 1; j < deltas.GetSize(); j++)

if (deltas[j] < deltas[i])

deltas.Swap(j, i);

for (i = deltas.GetSize() - 1; i > 0; i--)

{

_ASSERT(deltas[i] > deltas[i - 1]);

deltas.GetRef(i) -= deltas[i - 1];

}

#ifdef _DEBUG

{

unsigned size = 0;

for (i = 0; i < deltas.GetSize(); i++)

size += deltas[i];

_ASSERT(size == freeRegionSize);

}

#endif

}

//-----------------------------------------------------------------------------

void GenerateAndAddNopBlocks(const CkgSimpleContainerArray &deltas,

CkgArray &newArray,

AlgorithmParameters ¶meters,

cpp_arr_ptr vars[],

Block (*blocks)[2], bool isBA,

unsigned numFirstBlock)

{

_ASSERT(!deltas.IsEmpty());

for (unsigned i = 0; i < deltas.GetSize(); i++)

{

unsigned delta = deltas[i];

while (delta)

{

cpp_ptr nopBlock(new Block);

TestPtr(nopBlock);

CreateNopBlock(*nopBlock, parameters, *vars, delta);

unsigned nopBlockSize = nopBlock->GetSize();

_ASSERT(nopBlockSize && nopBlockSize <= delta);

delta -= nopBlockSize;

newArray.Add(*nopBlock);

nopBlock.Detach();

}

if (i != deltas.GetSize() - 1)

{

cpp_ptr tmp(new Block);

TestPtr(tmp);

unsigned size = blocks[numFirstBlock + i][isBA].GetSize();

for (unsigned j = 0; j < size; j++)

tmp->Add(blocks[numFirstBlock + i][isBA][j]);

newArray.Add(*tmp);

tmp.Detach();

}

}

}

//-----------------------------------------------------------------------------

void SmearAndAddNopBlocks(Block (*blocks)[2], bool isBA,

AlgorithmParameters ¶meters,

cpp_arr_ptr vars[],

CkgArray &newArray, unsigned addr)

{

_ASSERT(blocks && vars && newArray.IsEmpty());

unsigned i;

unsigned freeRegionSize = addr;

unsigned totalNumTrueBlocks = parameters.totalNumTrueBlocks;

unsigned blocksBeforeLoop = numBlocksBeforeLoop + parameters.numTransformation - 1;

unsigned blocksAfterLoop = totalNumTrueBlocks - blocksBeforeLoop;

for (i = 0; i < blocksBeforeLoop; i++)

freeRegionSize -= blocks[i][isBA].GetSize();

_ASSERT(static_cast(freeRegionSize) > 0); // Не ошибка, но "рисково" получилось.

CkgSimpleContainerArray deltas;

GenerateArrayRndDeltas(deltas, blocksBeforeLoop, freeRegionSize);

_ASSERT(deltas.GetSize() == blocksBeforeLoop + 1);

GenerateAndAddNopBlocks(deltas, newArray, parameters, vars,

blocks, isBA, 0);

#ifdef _DEBUG

{

unsigned size = 0;

for (i = 0; i < newArray.GetSize(); i++)

size += newArray[i].GetSize();

_ASSERT(size == addr);

}

#endif

deltas.Clear();

_ASSERT(parameters.sizeAlgorithm > addr);

freeRegionSize = parameters.sizeAlgorithm - addr;

for (i = blocksBeforeLoop; i < totalNumTrueBlocks; i++)

freeRegionSize -= blocks[i][isBA].GetSize();

_ASSERT(static_cast(freeRegionSize) > 0); // Не ошибка, но "рисково" получилось.

GenerateArrayRndDeltas(deltas, blocksAfterLoop, freeRegionSize);

_ASSERT(deltas.GetSize() == blocksAfterLoop + 1);

GenerateAndAddNopBlocks(deltas, newArray, parameters, vars,

blocks, isBA, blocksBeforeLoop);

}

//-----------------------------------------------------------------------------

static int DebugFindMaxBlockSize(unsigned n, const unsigned *sizes)

{

_ASSERT(n && sizes);

unsigned max = 0;

for (unsigned i = 0; i < n; i++)

if (max < sizes[i])

max = sizes[i];

_ASSERT(max);

return max;

}

//-----------------------------------------------------------------------------

static void DebugTestParam()

{

unsigned sum = 0;

sum += DebugFindMaxBlockSize(sizeBlocksArray_00, sizeBlocks_00);

sum += DebugFindMaxBlockSize(sizeBlocksArray_01, sizeBlocks_01);

sum += DebugFindMaxBlockSize(sizeBlocksArray_02, sizeBlocks_02);

sum += DebugFindMaxBlockSize(sizeBlocksArray_03, sizeBlocks_03);

sum += DebugFindMaxBlockSize(sizeBlocksArray_04, sizeBlocks_04);

sum += DebugFindMaxBlockSize(sizeBlocksArray_05, sizeBlocks_05);

sum += DebugFindMaxBlockSize(sizeBlocksArray_06, sizeBlocks_06);

sum += DebugFindMaxBlockSize(sizeBlocksArray_07, sizeBlocks_07);

WriteToLog(_T("Calc Max Algorithm Size = "), false);

WriteToLog(sum);

// Если меньше, то наверно легко словить ошибку.

_ASSERT(sum * 2 < minSizeAlgorithm);

}

//-----------------------------------------------------------------------------

void GenerateAlgorithm(pure_c_ptr &algorithmCrypt, size_t &sizeCrypt,

pure_c_ptr &algorithmDecrypt, size_t &sizeDecrypt,

unsigned deltaTimeCrypt, unsigned deltaTimeDecrypt)

{

WriteToLog(_T("GenerateAlgorithm()"));

#ifdef _DEBUG

DebugTestParam();

#endif

unsigned i, j;

AlgorithmParameters parameters[2];

RandomInitAlgorithmParameters(parameters);

cpp_arr_ptr vars[2];

for (unsigned k = 0; k < 2; k++)

{

vars[k] = new int[variablesNum * sizeof(int)];

TestPtr(vars[k]);

for (i = 0; i < variablesNum; i++)

vars[k][i] = CoolRand();

}

Block (*blocks)[2] = new Block[parameters[0].totalNumTrueBlocks][2];

cpp_arr_ptr memControl(blocks);

unsigned num = 0;

CreateBlock0(blocks[num++], parameters, vars);

CreateBlock1(blocks[num++], parameters, vars);

for (i = 0; i < parameters[0].numTransformation; i++)

CreateBlock2(blocks[num++], parameters, vars, i);

unsigned sizeBeforeLoop1, sizeBeforeLoop2;

CalcBlocksSize(blocks, num, sizeBeforeLoop1, sizeBeforeLoop2);

unsigned addr1 = 0, addr2 = 0;

CreateLoopAddres(num, parameters, sizeBeforeLoop1, sizeBeforeLoop2, addr1, addr2);

CkgSimpleContainerArray selectedBlocks;

CkgSimpleContainerArray arrUseCounterForModify;

for (i = 0; i < parameters[0].numTransformation; i++)

{

int numSelectedBlock = -1;

bool useCounterForModify = CoolRand(2) == 1;

CreateBlock3AB(blocks[num++], parameters, vars, i, numSelectedBlock,

useCounterForModify);

selectedBlocks.Add(numSelectedBlock);

arrUseCounterForModify.Add(useCounterForModify);

}

_ASSERT(selectedBlocks.GetSize() == parameters[0].numTransformation);

for (i = 0; i < parameters[0].numTransformation; i++)

{

CreateBlock3BA(blocks[num - 1 - i], parameters, vars, i,

selectedBlocks[i], arrUseCounterForModify[i]);

}

CreateBlock4(blocks[num++], parameters, vars);

CreateBlock5(blocks[num++], parameters, vars, addr1, addr2);

CreateBlock6(blocks[num++], parameters, vars, deltaTimeCrypt, deltaTimeDecrypt);

CreateBlock7(blocks[num++], parameters, vars);

_ASSERT(num == parameters[0].totalNumTrueBlocks);

CkgArray blocksAB;

Характеристики

Список файлов реферата