Xreferat.com » Рефераты по информатике и программированию » Защита информации в системах дистанционного обучения с монопольным доступом

Защита информации в системах дистанционного обучения с монопольным доступом

// Номер переменной или регистра где

// будет храниться счетчик.

unsigned initCounterNumber; // Какую переменную использовать для

// инициализации счетчика

unsigned totalNumTrueBlocks; // Сколько всего блоков должно получиться

// (без учета nops)


bool usedRegisters[registersNum]; // Занятые регистры.

bool usedVariables[variablesNum]; // Занятые перемненные.

};


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

#ifdef _DEBUG

void DebugTestBlock(int a)

{

unsigned sizeArrayAllSubstitution = CALC_ARRAY_SIZE(AllSubstitution);


_ASSERT(a != EO_ERROR);

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

_ASSERT(AllSubstitution[i] != a);


}

#define DEBUG_TEST_BLOCK(a) DebugTestBlock(a)

#else

#define DEBUG_TEST_BLOCK(a)

#endif // _DEBUG

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

int TestRegNum(int reg)

{

if (reg < 0 || reg >= registersNum)

CkgExcept(_T("error register number"));

return reg;

}

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

int TestVarNum(int var)

{

if (var < 0 || var >= variablesNum)

CkgExcept(_T("error variables number"));

return var;

}

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

void SkepValue(const int *&p)

{

E_OPERAND operand = static_cast(*p++);

switch (operand)

{

case EOP_REG:

case EOP_REF_REG:

case EOP_VAR:

case EOP_REF_VAR:

case EOP_CONST: *p++; return;

case EOP_RAND: return;

default: CkgExcept(_T("error operand type"));

}

}

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

int GetValue(const int *&p, int &variables, int ®isters, const int &data)

{

E_OPERAND operand = static_cast(*p++);

int reg, var;

switch (operand)

{

case EOP_REG: reg = TestRegNum(*p++);

WriteToLog(_T("REG_"), false);

WriteToLog(reg, false);

return (®isters)[reg];

case EOP_REF_REG: {

reg = TestRegNum(*p++);

int n = (®isters)[reg];

WriteToLog(_T("REF_REG_"), false);

WriteToLog(reg, false);

return (&data)[n];

}

case EOP_VAR: var = TestVarNum(*p++);

WriteToLog(_T("VAR_"), false);

WriteToLog(var, false);

return (&variables)[var];

case EOP_REF_VAR: {

var = TestVarNum(*p++);

int n = (&variables)[var];

WriteToLog(_T("REF_VAR_"), false);

WriteToLog(var, false);

return (&data)[n];

}

case EOP_CONST: WriteToLog(_T("CONST "), false);

return *p++;

case EOP_RAND: WriteToLog(_T("RAND "), false);

return CoolRand();

default: CkgExcept(_T("error operand type"));

}

return 0; // anti warning

}

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

void SetValue(const int *&p, int &variables, int ®isters, int &data,

int value)

{

E_OPERAND operand = static_cast(*p++);

int reg, var;

switch (operand)

{

case EOP_REG: reg = TestRegNum(*p++);

(®isters)[reg] = value;

WriteToLog(_T("REG_"), false);

WriteToLog(reg, false);

break;

case EOP_REF_REG: {

reg = TestRegNum(*p++);

int n = (®isters)[reg];

(&data)[n] = value;

WriteToLog(_T("REF_REG_"), false);

WriteToLog(reg, false);

break;

}

case EOP_VAR: var = TestVarNum(*p++);

(&variables)[var] = value;

WriteToLog(_T("VAR_"), false);

WriteToLog(var, false);

break;

case EOP_REF_VAR: {

var = TestVarNum(*p++);

int n = (&variables)[var];

(&data)[n] = value;

WriteToLog(_T("REF_VAR_"), false);

WriteToLog(var, false);

break;

}

default: CkgExcept(_T("error operand type"));

}

}

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

void TranslateOperations(const int &operations, const int &variables,

BYTE &memory)

{

const int *p = &operations;

cpp_arr_ptr vars(new int[variablesNum]);

TestPtr(vars);

cpp_arr_ptr regs(new int[registersNum]);

TestPtr(regs);

memcpy(vars.ptr(), &variables, variablesNum * sizeof(int));

memset(regs.ptr(), 0, registersNum * sizeof(int));

int *data = reinterpret_cast(&memory);

CkgSimpleContainerArray stack;

unsigned flags = 0;


WriteToLog(_T("rn=== Start TranslateOperations ===rn"));


E_OPERATION operation;

for (;;)

{

if (*p == EO_ERROR)

CkgExcept(IDS_PL_ERROR_INSTRUCTION_IN_ALG_0);

if (*p < 0 || *p > LAST_OPERATION)

CkgExcept(IDS_PL_ERROR_INSTRUCTION_IN_ALG);

operation = static_cast(*p++);

switch (operation)

{

case EO_EXIT_0: WriteToLog(_T("exit")); return;

case EO_EXIT_1: WriteToLog(_T("exit")); return;

case EO_EXIT_2: WriteToLog(_T("exit")); return;

case EO_NOP_0: break;

case EO_NOP_1: break;

case EO_NOP_2: break;

case EO_NOP_3: break;

case EO_MOV: {

WriteToLog(_T("mov "), false);

const int *oldP = p;

SkepValue(p);

int value = GetValue(p, *vars, *regs, *data);

WriteToLog(_T(" ==> "), false);

SetValue(oldP, *vars, *regs, *data, value);

WriteToLog(_T(""));

break;

}

case EO_XCHG: {

const int *oldP = p;

WriteToLog(_T("xchg "), false);

int value1 = GetValue(p, *vars, *regs, *data);

int value2 = GetValue(p, *vars, *regs, *data);

p = oldP;

WriteToLog(_T(" <==> "), false);

SetValue(p, *vars, *regs, *data, value2);

SetValue(p, *vars, *regs, *data, value1);

WriteToLog(_T(""));

break;

}

case EO_PUSH: {

WriteToLog(_T("push "), false);

int value = GetValue(p, *vars, *regs, *data);

WriteToLog(_T(""));

stack.Add(value);

break;

}

case EO_POP: {

WriteToLog(_T("pop "), false);

int value = stack.Remove(stack.GetSize() - 1);

Если Вам нужна помощь с академической работой (курсовая, контрольная, диплом, реферат и т.д.), обратитесь к нашим специалистам. Более 90000 специалистов готовы Вам помочь.
Бесплатные корректировки и доработки. Бесплатная оценка стоимости работы.

Поможем написать работу на аналогичную тему

Получить выполненную работу или консультацию специалиста по вашему учебному проекту
Нужна помощь в написании работы?
Мы - биржа профессиональных авторов (преподавателей и доцентов вузов). Пишем статьи РИНЦ, ВАК, Scopus. Помогаем в публикации. Правки вносим бесплатно.

Похожие рефераты: