Алексей Молчанов - Системное программное обеспечение. Лабораторный практикум

D:= 0;

B:= 1;

C:= 1;

A:= C + InpVar;

D:= C+B+234;

C:= A + B + C;

D:= ((C) +(A+B)) – (InpVar + 1) + (A+B);

E:= (D – 22) – (A + B);

CompileTest:= 0;

if (a

and (b<>e or not(b=0)))))))

a:=0 else a:=1;

if (InpVar > 0 or -1 <> InpVar)

while (a<1) do a:=a+(b+1)

else CompileTest:= InpVar+1;

end.

program MyCurs;

var

A,B,C,D,E: integer;

function CompileTest(InpVar: integer): integer; stdcall;

var

_Tmp0,_Tmp1: integer;

begin

asm

pushad {запоминаем регистры}

mov eax,0

mov D,eax { 1::= (D, 0) }

mov eax,1

mov B,eax { 2::= (B, 1) }

mov C,eax { 3::= (C, 1) }

add eax,InpVar { 4: + (C, InpVar) }

mov A,eax { 5::= (A, ^4) }

mov eax,C

add eax,B { 6: + (C, B) }

add eax,234 { 7: + (^6, 234) }

mov D,eax { 8::= (D, ^7) }

mov eax,A

add eax,B { 9: + (A, B) }

add eax,C { 10: + (^9, C) }

mov C,eax { 11::= (C, ^10) }

mov eax,A

add eax,B { 12: + (A, B) }

add eax,C { 13: + (C, ^12) }

mov ebx,eax

mov eax,InpVar

add eax,1 { 14: + (InpVar, 1) }

sub eax,ebx { 15: – (^13, ^14) }

neg eax

mov ebx,eax

mov eax,A

add eax,B { 16: + (A, B) }

add eax,ebx { 17: + (^15, ^16) }

mov D,eax { 18::= (D, ^17) }

sub eax,22 { 19: – (D, 22) }

mov ebx,eax

mov eax,A

add eax,B { 20: + (A, B) }

sub eax,ebx { 21: – (^19, ^20) }

neg eax

mov E,eax { 22::= (E, ^21) }

mov eax,0

mov Result,eax { 23::= (CompileTest, 0) }

mov eax,A

cmp eax,B { 24: < (A, B) }

setl al

and eax,1

mov ebx,eax

mov eax,A

cmp eax,C { 25: < (A, C) }

setl al

and eax,1

or eax,ebx { 26: or (^24, ^25) }

mov ebx,eax

mov eax,E

cmp eax,0 { 27: = (E, 0) }

sete al

and eax,1

mov ecx,eax

mov eax,D

cmp eax,0 { 28: = (D, 0) }

sete al

and eax,1

mov edx,eax

mov eax,B

cmp eax,C { 29: < (B, C) }

setl al

and eax,1

mov esi,eax

mov eax,A

cmp eax,C { 30: < (A, C) }

setl al

and eax,1

mov edi,eax

mov eax,C

cmp eax,E { 31: <> (C, E) }

setne al

and eax,1

mov _Tmp0,eax

mov eax,B

cmp eax,0 { 32: = (B, 0) }

sete al

and eax,1

not eax { 33: not (^32, 0) }

and eax,1

or eax,_Tmp0 { 34: or (^31, ^33) }

and eax,edi { 35: and (^30, ^34) }

or eax,esi { 36: or (^29, ^35) }

and eax,edx { 37: and (^28, ^36) }

xor eax,ecx { 38: xor (^27, ^37) }

xor eax,ebx { 39: xor (^26, ^38) }

jnz @F39 { 40: if (^39, ^43) }

jmp @M43

@F39:

mov eax,0

mov A,eax { 41::= (A, 0) }

jmp @M44 { 42: jmp (1, ^44) }

@M43:

mov eax,1

mov A,eax { 43::= (A, 1) }

@M44:

mov eax,InpVar

cmp eax,0 { 44: > (InpVar, 0) }

setg al

and eax,1

mov ebx,eax

mov eax,1

neg eax { 45: – (0, 1) }

cmp eax,InpVar { 46: <> (^45, InpVar) }

setne al

and eax,1

or eax,ebx { 47: or (^44, ^46) }

jnz @F47 { 48: if (^47, ^56) }

jmp @M56

@F47:

@M49:

mov eax,A

cmp eax,1 { 49: < (A, 1) }

setl al

and eax,1

jnz @F49 { 50: if (^49, ^55) }

jmp @M55

@F49:

mov eax,B

add eax,1 { 51: + (B, 1) }

add eax,A { 52: + (A, ^51) }

mov A,eax { 53::= (A, ^52) }

jmp @M49 { 54: jmp (1, ^49) }

@M55:

jmp @M58 { 55: jmp (1, ^58) }

@M56:

mov eax,InpVar

add eax,1 { 56: + (InpVar, 1) }

mov Result,eax { 57::= (CompileTest, ^56) }

@M58:

nop { 58: nop (0, 0) }

popad {восстанавливаем регистры}

end;

end;

var InpVar: integer;

begin

readln(InpVar);

writeln(CompileTest(InpVar));

readln;

end.

program MyCurs;

var

A,B,C,D,E: integer;

function CompileTest(InpVar: integer): integer; stdcall;

begin

asm

pushad {запоминаем регистры}

xor eax,eax

mov D,eax { 1::= (D, 0) }

inc eax

mov B,eax { 2::= (B, 1) }

mov C,eax { 3::= (C, 1) }

add eax,InpVar { 4: + (C, InpVar) }

mov A,eax { 5::= (A, ^4) }

mov eax,236

mov D,eax { 6::= (D, 236) }

mov eax,A

add eax,B { 7: + (A, B) }

mov ebx,eax

add eax,C { 8: + (^7, C) }

mov C,eax { 9::= (C, ^8) }

add eax,ebx { 10: + (C, ^7) }

mov ecx,eax

mov eax,InpVar

inc eax { 11: + (InpVar, 1) }

sub eax,ecx { 12: – (^10, ^11) }

neg eax

add eax,ebx { 13: + (^12, ^7) }

mov D,eax { 14::= (D, ^13) }

mov eax,214

sub eax,ebx { 15: – (214, ^7) }

mov E,eax { 16::= (E, ^15) }

xor eax,eax

mov Result,eax { 17::= (CompileTest, 0) }

mov eax,A

cmp eax,B { 18: < (A, B) }

setl al

and eax,1

mov ebx,eax

mov eax,A

cmp eax,C { 19: < (A, C) }

setl al

and eax,1

mov edx,eax

or eax,ebx { 20: or (^18, ^19) }

mov ebx,eax

mov eax,E

cmp eax,0 { 21: = (E, 0) }

sete al

and eax,1

mov ecx,eax

mov eax,C

cmp eax,E { 22: <> (C, E) }

setne al

and eax,1

xor eax,eax

inc eax { 23: or (^22, 1) }

and eax,edx { 24: and (^19, ^23) }

{ 25: or (0, ^24) }

xor eax,eax { 26: and (0, ^25) }

xor eax,ecx { 27: xor (^21, ^26) }

xor eax,ebx { 28: xor (^20, ^27) }

jnz @F28 { 29: if (^28, ^32) }

jmp @M32

@F28:

xor eax,eax

mov A,eax { 30::= (A, 0) }

jmp @M33 { 31: jmp (1, ^33) }

@M32:

xor eax,eax

inc eax

mov A,eax { 32::= (A, 1) }

@M33:

mov eax,InpVar

cmp eax,0 { 33: > (InpVar, 0) }

setg al