From cf49feb7fe996107bb7831a4617cd17ade17ade0 Mon Sep 17 00:00:00 2001 From: Mikael Pettersson Date: Mon, 3 Aug 2020 23:20:52 +0200 Subject: [PATCH] sim: sim_arithmetic: handle AOS{,L,E,LE,A,GE,N,G}, add unit tests --- erlang/apps/sim/src/sim_arithmetic.erl | 194 ++++++++++++++++++ erlang/apps/sim/src/sim_core.erl | 8 + erlang/apps/sim/test/sim_arithmetic_tests.erl | 169 +++++++++++++++ 3 files changed, 371 insertions(+) diff --git a/erlang/apps/sim/src/sim_arithmetic.erl b/erlang/apps/sim/src/sim_arithmetic.erl index ea6abc7..37fc5cd 100644 --- a/erlang/apps/sim/src/sim_arithmetic.erl +++ b/erlang/apps/sim/src/sim_arithmetic.erl @@ -34,6 +34,14 @@ , handle_AOJL/4 , handle_AOJLE/4 , handle_AOJN/4 + , handle_AOS/4 + , handle_AOSA/4 + , handle_AOSE/4 + , handle_AOSG/4 + , handle_AOSGE/4 + , handle_AOSL/4 + , handle_AOSLE/4 + , handle_AOSN/4 , handle_CAIE/4 , handle_CAIG/4 , handle_CAIGE/4 @@ -462,6 +470,192 @@ handle_AOJG(Core, Mem, IR, EA) -> {Word, Flags} = add1(CA), jump_if_G(sim_core:set_flags(sim_core:set_ac(Core, AC, Word), Flags), Mem, Word, EA). +%% AOS - Add One to Memory and Skip if Condition Satisfied + +-spec handle_AOS(#core{}, sim_mem:mem(), IR :: word(), #ea{}) + -> {#core{}, sim_mem:mem(), {ok, integer()} | {error, {module(), term()}}}. +handle_AOS(Core, Mem, IR, EA) -> + case sim_core:c(Core, Mem, EA) of + {ok, CE} -> + {Word, Flags} = add1(CE), + handle_AOS(Core, Mem, IR, EA, Word, Flags); + {error, Reason} -> + sim_core:page_fault(Core, Mem, ea_address(EA), read, Reason, + fun(Core1, Mem1) -> ?FUNCTION_NAME(Core1, Mem1, IR, EA) end) + end. + +handle_AOS(Core, Mem, IR, EA, Word, Flags) -> + case sim_core:cset(Core, Mem, EA, Word) of + {ok, Core1} -> + Core2 = set_non_zero_ac(Core1, IR, Word), + Core3 = sim_core:set_flags(Core2, Flags), + sim_core:next_pc(Core3, Mem); + {error, Reason} -> + sim_core:page_fault(Core, Mem, ea_address(EA), write, Reason, + fun(Core1, Mem1) -> ?FUNCTION_NAME(Core1, Mem1, IR, EA, Word, Flags) end) + end. + +-spec handle_AOSL(#core{}, sim_mem:mem(), IR :: word(), #ea{}) + -> {#core{}, sim_mem:mem(), {ok, integer()} | {error, {module(), term()}}}. +handle_AOSL(Core, Mem, IR, EA) -> + case sim_core:c(Core, Mem, EA) of + {ok, CE} -> + {Word, Flags} = add1(CE), + handle_AOSL(Core, Mem, IR, EA, Word, Flags); + {error, Reason} -> + sim_core:page_fault(Core, Mem, ea_address(EA), read, Reason, + fun(Core1, Mem1) -> ?FUNCTION_NAME(Core1, Mem1, IR, EA) end) + end. + +handle_AOSL(Core, Mem, IR, EA, Word, Flags) -> + case sim_core:cset(Core, Mem, EA, Word) of + {ok, Core1} -> + Core2 = set_non_zero_ac(Core1, IR, Word), + Core3 = sim_core:set_flags(Core2, Flags), + skip_if_L(Core3, Mem, sext36(Word), 0); + {error, Reason} -> + sim_core:page_fault(Core, Mem, ea_address(EA), write, Reason, + fun(Core1, Mem1) -> ?FUNCTION_NAME(Core1, Mem1, IR, EA, Word, Flags) end) + end. + +-spec handle_AOSE(#core{}, sim_mem:mem(), IR :: word(), #ea{}) + -> {#core{}, sim_mem:mem(), {ok, integer()} | {error, {module(), term()}}}. +handle_AOSE(Core, Mem, IR, EA) -> + case sim_core:c(Core, Mem, EA) of + {ok, CE} -> + {Word, Flags} = add1(CE), + handle_AOSE(Core, Mem, IR, EA, Word, Flags); + {error, Reason} -> + sim_core:page_fault(Core, Mem, ea_address(EA), read, Reason, + fun(Core1, Mem1) -> ?FUNCTION_NAME(Core1, Mem1, IR, EA) end) + end. + +handle_AOSE(Core, Mem, IR, EA, Word, Flags) -> + case sim_core:cset(Core, Mem, EA, Word) of + {ok, Core1} -> + Core2 = set_non_zero_ac(Core1, IR, Word), + Core3 = sim_core:set_flags(Core2, Flags), + skip_if_E(Core3, Mem, Word, 0); + {error, Reason} -> + sim_core:page_fault(Core, Mem, ea_address(EA), write, Reason, + fun(Core1, Mem1) -> ?FUNCTION_NAME(Core1, Mem1, IR, EA, Word, Flags) end) + end. + +-spec handle_AOSLE(#core{}, sim_mem:mem(), IR :: word(), #ea{}) + -> {#core{}, sim_mem:mem(), {ok, integer()} | {error, {module(), term()}}}. +handle_AOSLE(Core, Mem, IR, EA) -> + case sim_core:c(Core, Mem, EA) of + {ok, CE} -> + {Word, Flags} = add1(CE), + handle_AOSLE(Core, Mem, IR, EA, Word, Flags); + {error, Reason} -> + sim_core:page_fault(Core, Mem, ea_address(EA), read, Reason, + fun(Core1, Mem1) -> ?FUNCTION_NAME(Core1, Mem1, IR, EA) end) + end. + +handle_AOSLE(Core, Mem, IR, EA, Word, Flags) -> + case sim_core:cset(Core, Mem, EA, Word) of + {ok, Core1} -> + Core2 = set_non_zero_ac(Core1, IR, Word), + Core3 = sim_core:set_flags(Core2, Flags), + skip_if_LE(Core3, Mem, sext36(Word), 0); + {error, Reason} -> + sim_core:page_fault(Core, Mem, ea_address(EA), write, Reason, + fun(Core1, Mem1) -> ?FUNCTION_NAME(Core1, Mem1, IR, EA, Word, Flags) end) + end. + +-spec handle_AOSA(#core{}, sim_mem:mem(), IR :: word(), #ea{}) + -> {#core{}, sim_mem:mem(), {ok, integer()} | {error, {module(), term()}}}. +handle_AOSA(Core, Mem, IR, EA) -> + case sim_core:c(Core, Mem, EA) of + {ok, CE} -> + {Word, Flags} = add1(CE), + handle_AOSA(Core, Mem, IR, EA, Word, Flags); + {error, Reason} -> + sim_core:page_fault(Core, Mem, ea_address(EA), read, Reason, + fun(Core1, Mem1) -> ?FUNCTION_NAME(Core1, Mem1, IR, EA) end) + end. + +handle_AOSA(Core, Mem, IR, EA, Word, Flags) -> + case sim_core:cset(Core, Mem, EA, Word) of + {ok, Core1} -> + Core2 = set_non_zero_ac(Core1, IR, Word), + Core3 = sim_core:set_flags(Core2, Flags), + sim_core:skip(Core3, Mem); + {error, Reason} -> + sim_core:page_fault(Core, Mem, ea_address(EA), write, Reason, + fun(Core1, Mem1) -> ?FUNCTION_NAME(Core1, Mem1, IR, EA, Word, Flags) end) + end. + +-spec handle_AOSGE(#core{}, sim_mem:mem(), IR :: word(), #ea{}) + -> {#core{}, sim_mem:mem(), {ok, integer()} | {error, {module(), term()}}}. +handle_AOSGE(Core, Mem, IR, EA) -> + case sim_core:c(Core, Mem, EA) of + {ok, CE} -> + {Word, Flags} = add1(CE), + handle_AOSGE(Core, Mem, IR, EA, Word, Flags); + {error, Reason} -> + sim_core:page_fault(Core, Mem, ea_address(EA), read, Reason, + fun(Core1, Mem1) -> ?FUNCTION_NAME(Core1, Mem1, IR, EA) end) + end. + +handle_AOSGE(Core, Mem, IR, EA, Word, Flags) -> + case sim_core:cset(Core, Mem, EA, Word) of + {ok, Core1} -> + Core2 = set_non_zero_ac(Core1, IR, Word), + Core3 = sim_core:set_flags(Core2, Flags), + skip_if_LE(Core3, Mem, 0, sext36(Word)); % Word >= 0 -> 0 =< Word + {error, Reason} -> + sim_core:page_fault(Core, Mem, ea_address(EA), write, Reason, + fun(Core1, Mem1) -> ?FUNCTION_NAME(Core1, Mem1, IR, EA, Word, Flags) end) + end. + +-spec handle_AOSN(#core{}, sim_mem:mem(), IR :: word(), #ea{}) + -> {#core{}, sim_mem:mem(), {ok, integer()} | {error, {module(), term()}}}. +handle_AOSN(Core, Mem, IR, EA) -> + case sim_core:c(Core, Mem, EA) of + {ok, CE} -> + {Word, Flags} = add1(CE), + handle_AOSN(Core, Mem, IR, EA, Word, Flags); + {error, Reason} -> + sim_core:page_fault(Core, Mem, ea_address(EA), read, Reason, + fun(Core1, Mem1) -> ?FUNCTION_NAME(Core1, Mem1, IR, EA) end) + end. + +handle_AOSN(Core, Mem, IR, EA, Word, Flags) -> + case sim_core:cset(Core, Mem, EA, Word) of + {ok, Core1} -> + Core2 = set_non_zero_ac(Core1, IR, Word), + Core3 = sim_core:set_flags(Core2, Flags), + skip_if_N(Core3, Mem, Word, 0); + {error, Reason} -> + sim_core:page_fault(Core, Mem, ea_address(EA), write, Reason, + fun(Core1, Mem1) -> ?FUNCTION_NAME(Core1, Mem1, IR, EA, Word, Flags) end) + end. + +-spec handle_AOSG(#core{}, sim_mem:mem(), IR :: word(), #ea{}) + -> {#core{}, sim_mem:mem(), {ok, integer()} | {error, {module(), term()}}}. +handle_AOSG(Core, Mem, IR, EA) -> + case sim_core:c(Core, Mem, EA) of + {ok, CE} -> + {Word, Flags} = add1(CE), + handle_AOSG(Core, Mem, IR, EA, Word, Flags); + {error, Reason} -> + sim_core:page_fault(Core, Mem, ea_address(EA), read, Reason, + fun(Core1, Mem1) -> ?FUNCTION_NAME(Core1, Mem1, IR, EA) end) + end. + +handle_AOSG(Core, Mem, IR, EA, Word, Flags) -> + case sim_core:cset(Core, Mem, EA, Word) of + {ok, Core1} -> + Core2 = set_non_zero_ac(Core1, IR, Word), + Core3 = sim_core:set_flags(Core2, Flags), + skip_if_L(Core3, Mem, 0, sext36(Word)); % Word > 0 -> 0 < Word + {error, Reason} -> + sim_core:page_fault(Core, Mem, ea_address(EA), write, Reason, + fun(Core1, Mem1) -> ?FUNCTION_NAME(Core1, Mem1, IR, EA, Word, Flags) end) + end. + %% Miscellaneous =============================================================== jump_if_E(Core, Mem, X, EA) -> diff --git a/erlang/apps/sim/src/sim_core.erl b/erlang/apps/sim/src/sim_core.erl index 6dec169..b20703c 100644 --- a/erlang/apps/sim/src/sim_core.erl +++ b/erlang/apps/sim/src/sim_core.erl @@ -328,6 +328,14 @@ dispatch(Core, Mem, IR, EA) -> 8#345 -> sim_arithmetic:handle_AOJGE(Core, Mem, IR, EA); 8#346 -> sim_arithmetic:handle_AOJN(Core, Mem, IR, EA); 8#347 -> sim_arithmetic:handle_AOJG(Core, Mem, IR, EA); + 8#350 -> sim_arithmetic:handle_AOS(Core, Mem, IR, EA); + 8#351 -> sim_arithmetic:handle_AOSL(Core, Mem, IR, EA); + 8#352 -> sim_arithmetic:handle_AOSE(Core, Mem, IR, EA); + 8#353 -> sim_arithmetic:handle_AOSLE(Core, Mem, IR, EA); + 8#354 -> sim_arithmetic:handle_AOSA(Core, Mem, IR, EA); + 8#355 -> sim_arithmetic:handle_AOSGE(Core, Mem, IR, EA); + 8#356 -> sim_arithmetic:handle_AOSN(Core, Mem, IR, EA); + 8#357 -> sim_arithmetic:handle_AOSG(Core, Mem, IR, EA); 8#400 -> sim_boolean:handle_SETZ(Core, Mem, IR, EA); 8#401 -> sim_boolean:handle_SETZ(Core, Mem, IR, EA); % SETZI = SETZ 8#402 -> sim_boolean:handle_SETZM(Core, Mem, IR, EA); diff --git a/erlang/apps/sim/test/sim_arithmetic_tests.erl b/erlang/apps/sim/test/sim_arithmetic_tests.erl index 791abf1..f97727d 100644 --- a/erlang/apps/sim/test/sim_arithmetic_tests.erl +++ b/erlang/apps/sim/test/sim_arithmetic_tests.erl @@ -95,6 +95,14 @@ -define(OP_AOJGE, 8#345). -define(OP_AOJN, 8#346). -define(OP_AOJG, 8#347). +-define(OP_AOS, 8#350). +-define(OP_AOSL, 8#351). +-define(OP_AOSE, 8#352). +-define(OP_AOSLE, 8#353). +-define(OP_AOSA, 8#354). +-define(OP_AOSGE, 8#355). +-define(OP_AOSN, 8#356). +-define(OP_AOSG, 8#357). %% 2.6.1 Add One to Both Halves of AC and Jump ================================= @@ -831,6 +839,167 @@ aojg_test() -> expect(Prog2, [], {1, 8#102}, ?DEFAULT_FLAGS, % no jump [ {?AC(1), ?LOW36(-1)}]). % AC(1) = -1 +%% AOS - Add One to Memory and Skip if Condition Satisfied + +aos_test() -> + Prog = + [ {1, 8#101, ?INSN(?OP_AOS, 1, 0, 0, 8#150)} % 1,,101/ AOS 1,150 + , {1, 8#102, ?INSN_INVALID} % 1,,102/ + , {1, 8#150, ?LOW36(2)} % 1,,150/ 2 + ], + expect(Prog, [], {1, 8#102}, ?DEFAULT_FLAGS, % no jump + [ {?EA(1, 8#150), ?LOW36(3)} % C(1,,150) = 3 + , {?AC(1), ?LOW36(3)}]). % AC(1) = 3 + +aosl_test() -> + Prog1 = + [ {1, 8#101, ?INSN(?OP_AOSL, 1, 0, 0, 8#150)} % 1,,101/ AOSL 1,150 + , {1, 8#102, ?INSN_INVALID} % 1,,102/ + , {1, 8#103, ?INSN_INVALID} % 1,,103/ + , {1, 8#150, ?LOW36(-2)} % 1,,150/ -2 + ], + expect(Prog1, [], {1, 8#103}, ?DEFAULT_FLAGS, % jump + [ {?EA(1, 8#150), ?LOW36(-1)} % C(1,,150) = -1 + , {?AC(1), ?LOW36(-1)}]), % AC(1) = -1 + Prog2 = + [ {1, 8#101, ?INSN(?OP_AOSL, 1, 0, 0, 8#150)} % 1,,101/ AOSL 1,150 + , {1, 8#102, ?INSN_INVALID} % 1,,102/ + , {1, 8#103, ?INSN_INVALID} % 1,,103/ + , {1, 8#150, ?LOW36(2)} % 1,,150/ 2 + ], + expect(Prog2, [], {1, 8#102}, ?DEFAULT_FLAGS, % no jump + [ {?EA(1, 8#150), ?LOW36(3)} % C(1,,150) = 3 + , {?AC(1), ?LOW36(3)}]). % AC(1) = 3 + +aose_test() -> + Prog1 = + [ {1, 8#101, ?INSN(?OP_AOSE, 1, 0, 0, 8#150)} % 1,,101/ AOSE 1,150 + , {1, 8#102, ?INSN_INVALID} % 1,,102/ + , {1, 8#103, ?INSN_INVALID} % 1,,103/ + , {1, 8#150, ?LOW36(-1)} % 1,,150/ -1 + ], + expect(Prog1, [], {1, 8#103}, ?CARRY_FLAGS, % jump, carry 0 and 1 + [ {?EA(1, 8#150), ?LOW36(0)} % C(1,,150) = 0 + , {?AC(1), ?LOW36(0)}]), % AC(1) = 0 + Prog2 = + [ {1, 8#101, ?INSN(?OP_AOSE, 1, 0, 0, 8#150)} % 1,,101/ AOSE 1,150 + , {1, 8#102, ?INSN_INVALID} % 1,,102/ + , {1, 8#103, ?INSN_INVALID} % 1,,103/ + , {1, 8#150, ?LOW36(2)} % 1,,150/ 2 + ], + expect(Prog2, [], {1, 8#102}, ?DEFAULT_FLAGS, % no jump + [ {?EA(1, 8#150), ?LOW36(3)} % C(1,,150) = 3 + , {?AC(1), ?LOW36(3)}]). % AC(1) = 3 + +aosle_test() -> + Prog1 = + [ {1, 8#101, ?INSN(?OP_AOSLE, 1, 0, 0, 8#150)} % 1,,101/ AOSLE 1,150 + , {1, 8#102, ?INSN_INVALID} % 1,,102/ + , {1, 8#103, ?INSN_INVALID} % 1,,103/ + , {1, 8#150, ?LOW36(-2)} % 1,,150/ -2 + ], + expect(Prog1, [], {1, 8#103}, ?DEFAULT_FLAGS, % jump + [ {?EA(1, 8#150), ?LOW36(-1)} % C(1,,150) = -1 + , {?AC(1), ?LOW36(-1)}]), % AC(1) = -1 + Prog2 = + [ {1, 8#101, ?INSN(?OP_AOSLE, 1, 0, 0, 8#150)} % 1,,101/ AOSLE 1,150 + , {1, 8#102, ?INSN_INVALID} % 1,,102/ + , {1, 8#103, ?INSN_INVALID} % 1,,103/ + , {1, 8#150, ?LOW36(-1)} % 1,,150/ -1 + ], + expect(Prog2, [], {1, 8#103}, ?CARRY_FLAGS, % jump, carry 0 and 1 + [ {?EA(1, 8#150), ?LOW36(0)} % C(1,,150) = 0 + , {?AC(1), ?LOW36(0)}]), % AC(1) = 0 + Prog3 = + [ {1, 8#101, ?INSN(?OP_AOSLE, 1, 0, 0, 8#150)} % 1,,101/ AOSLE 1,150 + , {1, 8#102, ?INSN_INVALID} % 1,,102/ + , {1, 8#103, ?INSN_INVALID} % 1,,103/ + , {1, 8#150, ?LOW36(2)} % 1,,150/ 2 + ], + expect(Prog3, [], {1, 8#102}, ?DEFAULT_FLAGS, % no jump + [ {?EA(1, 8#150), ?LOW36(3)} % C(1,,150) = 3 + , {?AC(1), ?LOW36(3)}]). % AC(1) = 3 + +aosa_test() -> + Prog = + [ {1, 8#101, ?INSN(?OP_AOSA, 1, 0, 0, 8#150)} % 1,,101/ AOSA 1,150 + , {1, 8#102, ?INSN_INVALID} % 1,,102/ + , {1, 8#103, ?INSN_INVALID} % 1,,103/ + , {1, 8#150, ?LOW36(2)} % 1,,150/ 2 + ], + expect(Prog, [], {1, 8#103}, ?DEFAULT_FLAGS, % jump + [ {?EA(1, 8#150), ?LOW36(3)} % C(1,,150) = 3 + , {?AC(1), ?LOW36(3)}]). % AC(1) = 3 + +aosge_test() -> + Prog1 = + [ {1, 8#101, ?INSN(?OP_AOSGE, 1, 0, 0, 8#150)} % 1,,101/ AOSGE 1,150 + , {1, 8#102, ?INSN_INVALID} % 1,,102/ + , {1, 8#103, ?INSN_INVALID} % 1,,103/ + , {1, 8#150, ?LOW36(2)} % 1,,150/ 2 + ], + expect(Prog1, [], {1, 8#103}, ?DEFAULT_FLAGS, % jump + [ {?EA(1, 8#150), ?LOW36(3)} % C(1,,150) = 3 + , {?AC(1), ?LOW36(3)}]), % AC(1) = 3 + Prog2 = + [ {1, 8#101, ?INSN(?OP_AOSGE, 1, 0, 0, 8#150)} % 1,,101/ AOSGE 1,150 + , {1, 8#102, ?INSN_INVALID} % 1,,102/ + , {1, 8#103, ?INSN_INVALID} % 1,,103/ + , {1, 8#150, ?LOW36(-1)} % 1,,150/ -1 + ], + expect(Prog2, [], {1, 8#103}, ?CARRY_FLAGS, % jump, carry 0 and 1 + [ {?EA(1, 8#150), ?LOW36(0)} % C(1,,150) = 0 + , {?AC(1), ?LOW36(0)}]), % AC(1) = 0 + Prog3 = + [ {1, 8#101, ?INSN(?OP_AOSGE, 1, 0, 0, 8#150)} % 1,,101/ AOSGE 1,150 + , {1, 8#102, ?INSN_INVALID} % 1,,102/ + , {1, 8#103, ?INSN_INVALID} % 1,,103/ + , {1, 8#150, ?LOW36(-2)} % 1,,150/ -2 + ], + expect(Prog3, [], {1, 8#102}, ?DEFAULT_FLAGS, % no jump + [ {?EA(1, 8#150), ?LOW36(-1)} % C(1,,150) = -1 + , {?AC(1), ?LOW36(-1)}]). % AC(1) = -1 + +aosn_test() -> + Prog1 = + [ {1, 8#101, ?INSN(?OP_AOSN, 1, 0, 0, 8#150)} % 1,,101/ AOSN 1,150 + , {1, 8#102, ?INSN_INVALID} % 1,,102/ + , {1, 8#103, ?INSN_INVALID} % 1,,103/ + , {1, 8#150, ?LOW36(2)} % 1,,150/ 2 + ], + expect(Prog1, [], {1, 8#103}, ?DEFAULT_FLAGS, % jump + [ {?EA(1, 8#150), ?LOW36(3)} % C(1,,150) = 3 + , {?AC(1), ?LOW36(3)}]), % AC(1) = 3 + Prog2 = + [ {1, 8#101, ?INSN(?OP_AOSN, 1, 0, 0, 8#150)} % 1,,101/ AOSN 1,150 + , {1, 8#102, ?INSN_INVALID} % 1,,102/ + , {1, 8#103, ?INSN_INVALID} % 1,,103/ + , {1, 8#150, ?LOW36(-1)} % 1,,150/ -1 + ], + expect(Prog2, [], {1, 8#102}, ?CARRY_FLAGS, % no jump, carry 0 and 1 + [ {?EA(1, 8#150), ?LOW36(0)} % C(1,,150) = 0 + , {?AC(1), ?LOW36(0)}]). % AC(1) = 0 + +aosg_test() -> + Prog1 = + [ {1, 8#101, ?INSN(?OP_AOSG, 1, 0, 0, 8#150)} % 1,,101/ AOSG 1,150 + , {1, 8#102, ?INSN_INVALID} % 1,,102/ + , {1, 8#103, ?INSN_INVALID} % 1,,103/ + , {1, 8#150, ?LOW36(2)} % 1,,150/ 2 + ], + expect(Prog1, [], {1, 8#103}, ?DEFAULT_FLAGS, % jump + [ {?EA(1, 8#150), ?LOW36(3)} % C(1,,150) = 3 + , {?AC(1), ?LOW36(3)}]), % AC(1) = 3 + Prog2 = + [ {1, 8#101, ?INSN(?OP_AOSG, 1, 0, 0, 8#150)} % 1,,101/ AOSG 1,150 + , {1, 8#102, ?INSN_INVALID} % 1,,102/ + , {1, 8#103, ?INSN_INVALID} % 1,,103/ + , {1, 8#150, ?LOW36(-2)} % 1,,150/ -2 + ], + expect(Prog2, [], {1, 8#102}, ?DEFAULT_FLAGS, % no jump + [ {?EA(1, 8#150), ?LOW36(-1)} % C(1,,150) = -1 + , {?AC(1), ?LOW36(-1)}]). % AC(1) = -1 + %% Common code to run short sequences ========================================== expect(Prog, ACs, ExpectedPC, ExpectedFlags, ExpectedEs) ->