/**
 * Warranty & Liability
 * To the extent permitted by applicable law and unless explicitly
 * otherwise agreed upon, XLOG Technologies AG makes no warranties
 * regarding the provided information. XLOG Technologies AG assumes
 * no liability that any problems might be solved with the information
 * provided by XLOG Technologies AG.
 *
 * Rights & License
 * All industrial property rights regarding the information - copyright
 * and patent rights in particular - are the sole property of XLOG
 * Technologies AG. If the company was not the originator of some
 * excerpts, XLOG Technologies AG has at least obtained the right to
 * reproduce, change and translate the information.
 *
 * Reproduction is restricted to the whole unaltered document. Reproduction
 * of the information is only allowed for non-commercial uses. Selling,
 * giving away or letting of the execution of the library is prohibited.
 * The library can be distributed as part of your applications and libraries
 * for execution provided this comment remains unchanged.
 *
 * Restrictions
 * Only to be distributed with programs that add significant and primary
 * functionality to the library. Not to be distributed with additional
 * software intended to replace any components of the library.
 *
 * Trademarks
 * Jekejeke is a registered trademark of XLOG Technologies AG.
 */

:- ensure_loaded(library(misc/brainfog)).
:- ensure_loaded(library(misc/intercom)).

/***************************************************************/
/* Emulator                                                    */
/***************************************************************/

/**
 * emulate(G):
 * emulate(G, O):
 * The predicate succeeds. As a side effect it emulates G
 * on an abstract π-WAM. The binary predicate allows
 * specifying hack options O.
 */
% emulate(+Goal)
emulate(GOAL) :-
   emulate(GOAL, []).

% emulate(+Goal, +List)
emulate(GOAL, OPTS) :-
   sys_hack_opts(OPTS, v(1,[],[]), v(NUM,_,_)),
   sys_trans_body(GOAL, nothing, MARK, 1, CONT, []),
   (sys_comp_comp(MARK, CONT, NUM, CODE, OFFSETS, CHANS, STATE),
       sys_hack_init(OFFSETS, 0, STATE, STATE2),
       sys_hack_run(OFFSETS, CODE, CHANS, STATE2);
       true).

% sys_hack_init(+List, +Integer, +List, -List)
sys_hack_init([], _, STATE, STATE).
sys_hack_init([OFFSET|MORE], ID, STATE, STATE3) :-
   IDX is OFFSET-3,
   nth0(IDX, STATE, _, TEMP),
   nth0(IDX, STATE2, ID, TEMP),
   ID2 is ID+1,
   sys_hack_init(MORE, ID2, STATE2, STATE3).

% sys_hack_run(+List, +List, +List, +List)
sys_hack_run([], _, _, _) :- !, fail.
sys_hack_run(OFFSETS, CODE, CHANS, STATE) :-
   sys_hack_robin(OFFSETS, CODE, CHANS, STATE, OFFSETS2, STATE2),
   sys_hack_run(OFFSETS2, CODE, CHANS, STATE2).

% sys_hack_robin(+List, +List, +List, +List, -List)
sys_hack_robin([OFFSET|MORE], CODE, CHANS, STATE, [OFFSET|REST], STATE3) :-
   sys_hack_step(CODE, OFFSET, CHANS, STATE, STATE2), !,
   sys_hack_robin(MORE, CODE, CHANS, STATE2, REST, STATE3).
sys_hack_robin([_|MORE], CODE, CHANS, STATE, REST, STATE2) :-
   sys_hack_robin(MORE, CODE, CHANS, STATE, REST, STATE2).
sys_hack_robin([], _, _, STATE, [], STATE).

% sys_hack_step(+List, +Integer, +List, +List, -List)
sys_hack_step(CODE, OFFSET, CHANS, STATE, STATE5) :-
   IDX is OFFSET-2,
   nth0(IDX, STATE, PC),
   IDX2 is OFFSET-1,
   nth0(IDX2, STATE, ACCU),
   nth0(PC, CODE, (MODE, FUN, OBJ)),
   sys_hack_get(MODE, OBJ, CHANS, OFFSET, CODE, STATE, PC, STATE2, VALUE),
   sys_hack_set(MODE, OBJ, ACCU, OFFSET, STATE2, PC, STATE3, PC2),
   sys_hack_fun(FUN, ACCU, VALUE, ACCU2),
   nth0(IDX, STATE3, _, TEMP),
   nth0(IDX, STATE4, PC2, TEMP),
   nth0(IDX2, STATE4, _, TEMP2),
   nth0(IDX2, STATE5, ACCU2, TEMP2).

/***************************************************************/
/* Instructions                                                */
/***************************************************************/

% sys_hack_get(+Atom, +Integer, +List, +Integer, +List, +List, +Integer, -List, -Integer)
sys_hack_get(cst, VALUE, _, _, _, STATE, _, STATE, VALUE).
sys_hack_get(get, OBJ, _, OFFSET, _, STATE, _, STATE, VALUE) :-
   IDX is OFFSET+OBJ,
   nth0(IDX, STATE, VALUE).
sys_hack_get(ext, _, _, _, CODE, STATE, PC, STATE, VALUE) :-
   IDX is PC+1,
   nth0(IDX, CODE, VALUE).
sys_hack_get(out, OBJ, CHANS, OFFSET, _, STATE, _, STATE, VALUE) :-
   nth0(OFFSET, STATE, MAX),
   AT is OFFSET+1,
   (sys_extra_output(OBJ, CHANS, MAX, STATE, AT) ->
    VALUE = 1; VALUE = 0).
sys_hack_get(in, OBJ, CHANS, OFFSET, _, STATE, _, STATE2, VALUE) :-
   nth0(OFFSET, STATE, MAX),
   AT is OFFSET+1,
   (sys_extra_input(OBJ, CHANS, MAX, STATE, AT, STATE2) ->
    VALUE = 1; STATE2 = STATE, VALUE = 0).
sys_hack_get(set, _, _, _, _, STATE, _, STATE, 0).
sys_hack_get(bra, _, _, _, _, STATE, PC, STATE, PC2) :-
   PC2 is PC+1.
sys_hack_get(brz, _, _, _, _, STATE, PC, STATE, PC2) :-
   PC2 is PC+1.
sys_hack_get(jma, _, _, _, _, STATE, PC, STATE, PC2) :-
   PC2 is PC+1.
sys_hack_get(jmz, _, _, _, _, STATE, PC, STATE, PC2) :-
   PC2 is PC+1.

% sys_hack_set(+Atom, +Integer, +Integer, +Integer, +List, +Integer, -List, -Integer)
sys_hack_set(cst, _, _, _, STATE, PC, STATE, PC2) :-
   PC2 is PC+1.
sys_hack_set(get, _, _, _, STATE, PC, STATE, PC2) :-
   PC2 is PC+1.
sys_hack_set(ext, _, _, _, STATE, PC, STATE, PC2) :-
   PC2 is PC+2.
sys_hack_set(out, _, _, _, STATE, PC, STATE, PC2) :-
   PC2 is PC+1.
sys_hack_set(in, _, _, _, STATE, PC, STATE, PC2) :-
   PC2 is PC+1.
sys_hack_set(set, OBJ, ACCU, OFFSET, STATE, PC, STATE2, PC2) :-
   IDX is OFFSET+OBJ,
   nth0(IDX, STATE, _, TEMP),
   nth0(IDX, STATE2, ACCU, TEMP),
   PC2 is PC+1.
sys_hack_set(bra, PC2, _, _, STATE, _, STATE, PC2).
sys_hack_set(brz, OBJ, ACCU, _, STATE, PC, STATE, PC2) :-
   (ACCU =:= 0 ->
    PC2 = OBJ; PC2 is PC+1).
sys_hack_set(jma, OBJ, _, OFFSET, STATE, _, STATE, PC2) :-
   IDX is OFFSET+OBJ,
   nth0(IDX, STATE, PC2).
sys_hack_set(jmz, OBJ, ACCU, OFFSET, STATE, PC, STATE, PC2) :-
   (ACCU =:= 0 ->
    IDX is OFFSET+OBJ,
    nth0(IDX, STATE, PC2); PC2 is PC+1).

% sys_hack_fun(+Atom, +Integer, +Integer, -Integer)
sys_hack_fun(mov, _, VALUE, VALUE).
sys_hack_fun(neg, _, VALUE, VALUE2) :-
   TEMP is -VALUE,
   sys_int32(TEMP, VALUE2).
sys_hack_fun(add, ACCU, VALUE, VALUE2) :-
   TEMP is ACCU+VALUE,
   sys_int32(TEMP, VALUE2).
sys_hack_fun(sub, ACCU, VALUE, VALUE2) :-
   TEMP is ACCU-VALUE,
   sys_int32(TEMP, VALUE2).
sys_hack_fun(mul, ACCU, VALUE, VALUE2) :-
   TEMP is ACCU*VALUE,
   sys_int32(TEMP, VALUE2).
sys_hack_fun(zdiv, ACCU, VALUE, VALUE2) :-
   TEMP is ACCU//VALUE,
   sys_int32(TEMP, VALUE2).
sys_hack_fun(rem, ACCU, VALUE, VALUE2) :-
   TEMP is ACCU rem VALUE,
   sys_int32(TEMP, VALUE2).
sys_hack_fun(min, ACCU, VALUE, VALUE2) :-
   VALUE2 is min(ACCU,VALUE).
sys_hack_fun(max, ACCU, VALUE, VALUE2) :-
   VALUE2 is max(ACCU,VALUE).
sys_hack_fun(eq, ACCU, VALUE, VALUE2) :-
   (ACCU =:= VALUE -> VALUE2 = 1; VALUE2 = 0).
sys_hack_fun(nq, ACCU, VALUE, VALUE2) :-
   (ACCU =\= VALUE -> VALUE2 = 1; VALUE2 = 0).
sys_hack_fun(ls, ACCU, VALUE, VALUE2) :-
   (ACCU < VALUE -> VALUE2 = 1; VALUE2 = 0).
sys_hack_fun(gr, ACCU, VALUE, VALUE2) :-
   (ACCU > VALUE -> VALUE2 = 1; VALUE2 = 0).
sys_hack_fun(lq, ACCU, VALUE, VALUE2) :-
   (ACCU =< VALUE -> VALUE2 = 1; VALUE2 = 0).
sys_hack_fun(gq, ACCU, VALUE, VALUE2) :-
   (ACCU >= VALUE -> VALUE2 = 1; VALUE2 = 0).

% sys_int32(+Integer, -Integer)
sys_int32(ALPHA, RESULT) :-
   MASKED is ALPHA /\ 0xFFFFFFFF,
   (MASKED >= 0x80000000 ->
      RESULT is MASKED - 0x100000000;
      RESULT = MASKED).

/***************************************************************/
/* Hack Output/Input                                           */
/***************************************************************/

% sys_extra_output(+Integer, +List, +Integer, +List, +Integer)
sys_extra_output(OBJ, CHANS, MAX, STATE, AT) :-
   nth0(OBJ, CHANS, CHAN),
   sys_load_ints(LIST, MAX, STATE, AT),
   cpu_buf_new(LIST, BUF),
   cpu_xbar_offer(CHAN, BUF).

% sys_extra_input(+Integer, +List, +Integer, +List, +Integer, -List)
sys_extra_input(OBJ, CHANS, MAX, STATE, AT, STATE2) :-
   nth0(OBJ, CHANS, CHAN),
   os_obj_new(MAP),
   os_obj_set(MAP, 'len', MAX),
   cpu_xbar_poll(CHAN, MAP),
   os_obj_current(MAP, 'len', LEN),
   (LEN = MAX ->
      os_obj_current(MAP, 'data', BUF),
      cpu_buf_current(BUF, LIST),
      sys_store_ints(LIST, STATE, AT, STATE2);
      sys_store_miss(LEN, STATE, AT, STATE2)).

/***************************************************************/
/* Hack Load/Store                                             */
/***************************************************************/

% sys_load_ints(-List, +Integer, +List, +Integer)
sys_load_ints([VALUE|LIST], MAX, STATE, AT) :- MAX > 0, !,
   nth0(AT, STATE, VALUE),
   AT2 is AT+1, MAX2 is MAX-1,
   sys_load_ints(LIST, MAX2, STATE, AT2).
sys_load_ints([], _, _, _).

% sys_store_ints(+List, +List, +Integer, -List)
sys_store_ints([VALUE|LIST], STATE, AT, STATE2) :-
   nth0(AT, STATE, _, TEMP),
   nth0(AT, STATE3, VALUE, TEMP),
   AT2 is AT+1,
   sys_store_ints(LIST, STATE3, AT2, STATE2).
sys_store_ints([], STATE, _, STATE).

% sys_store_miss(+Integer, +List, +Integer, -List)
sys_store_miss(VALUE, STATE, AT, STATE2) :-
   AT2 is AT-1,
   nth0(AT2, STATE, _, TEMP),
   nth0(AT2, STATE2, VALUE, TEMP).

/****************************************************************/
/* Disassembler                                                 */
/****************************************************************/

% instructions(+Goal)
instructions(GOAL) :-
   sys_trans_body(GOAL, nothing, MARK, 1, CONT, []),
   (sys_comp_prog(MARK, CONT, CODE, _, _),
       sys_disasm_code(0-CODE, _-[]),
       fail;
       true).

% sys_disasm_code(+Pair, -Pair)
sys_disasm_code --> sys_label(STEP), sys_instr((MODE, FUN, OBJ)), !,
   sys_disasm_instr(MODE, FUN, OBJ, LIST),
   {format('~t~d~5|: ~w ~p, ~p', [STEP|LIST]), nl},
   sys_disasm_code.
sys_disasm_code --> [].

% sys_disasm_instr(+Atom, +Atom, +Integer, -List, +Pair, -Pair)
sys_disasm_instr(cst, FUN, OBJ, [FUN, 'A', OBJ]) --> [].
sys_disasm_instr(get, FUN, OBJ, [FUN, 'A', [OBJ]]) --> [].
sys_disasm_instr(ext, FUN, _, [FUN, 'A', OBJ]) -->
   sys_instr(OBJ).
sys_disasm_instr(out, FUN, OBJ, [FUN, 'A', out(OBJ)]) --> [].
sys_disasm_instr(in, FUN, OBJ, [FUN, 'A', in(OBJ)]) --> [].
sys_disasm_instr(set, mov, OBJ, [mov, [OBJ], 'A']) --> [].
sys_disasm_instr(bra, mov, OBJ, [jmz, 0, OBJ]) --> [].
sys_disasm_instr(brz, mov, OBJ, [jmz, 'A', OBJ]) --> [].
sys_disasm_instr(jma, mov, OBJ, [jmz, 0, [OBJ]]) --> [].
sys_disasm_instr(jmz, mov, OBJ, [jmz, 'A', [OBJ]]) --> [].
