source: Deliverables/D4.1/ASMInterpret.mli @ 336

open BitVectors;;
open Physical;;

exception CodeTooLarge

type time = int;;
type line = [ `P1 of byte
            | `P3 of byte
            | `SerialBuff of [ `Eight of byte
                             | `Nine of BitVectors.bit * byte
                             ]
            ];;

val string_of_line: line -> string;;

type epsilon = int;;

(* In:  reception time, line of input, new continuation,
   Out: transmission time, output line, expected duration until reply,
        new continuation.
*)
type continuation =
  [`In of time * line * epsilon * continuation] option *
  [`Out of (time -> line -> time * continuation) ];;

type status =
{
  (* Memory *)
  code_memory: WordMap.map;        (* can be reduced *)
  low_internal_ram: Byte7Map.map;
  high_internal_ram: Byte7Map.map;
  external_ram: WordMap.map;

  (* Program counter *)
  pc: word;

  (* SFRs *)
  sp: byte;
  dpl: byte;
  dph: byte;
  pcon: byte;
  tcon: byte;
  tmod: byte;
  tl0: byte;
  tl1: byte;
  th0: byte;
  th1: byte;
  p1: byte;
  scon: byte;
  sbuf: byte;
  ie: byte;
  p3: byte;
  ip: byte;
  psw: byte;
  acc: byte;
  b: byte;
  t2con: byte;   (* 8052 only *)
  rcap2l: byte;  (* 8052 only *)
  rcap2h: byte;  (* 8052 only *)
  tl2: byte;     (* 8052 only *)
  th2: byte;     (* 8052 only *)

  (* Latches for the output lines *)
  p1_latch: byte;
  p3_latch: byte;

  (* Fields for tracking the state of the processor. *)
  
  (* IO specific *)
  previous_p1_val: bool;
  previous_p3_val: bool;

  serial_epsilon_out: epsilon option;
  serial_epsilon_in: epsilon option;

  io_epsilon: epsilon;

  serial_v_in: [`Eight of byte | `Nine of (BitVectors.bit * byte) ] option;
  serial_v_out: [`Eight of byte | `Nine of (BitVectors.bit * byte) ] option;

  serial_k_out: continuation option;

  io: continuation;
  expected_out_time: [ `None | `Now | `At of time ];

  (* Timer and clock specific *)
  clock: time;
  timer0: word;
  timer1: word;
  timer2: word;  (* can be missing *)

  esi_running: bool;
  t0i_running: bool;
  t1i_running: bool;
  e0i_running: bool;
  e1i_running: bool;
  es_running: bool;
}

val string_of_status: status -> string

module IntMap: Map.S with type key = int

val assembly: ASM.assembly_program -> BitVectors.byte list (*ASM.instruction list * symbol_table *) * string IntMap.t

(*
val link:
 (ASM.instruction list * symbol_table * cost_map) list -> BitVectors.byte list
*)

val initialize: status

val load_mem: Physical.WordMap.map -> status -> status
val load: BitVectors.byte list -> status -> status

exception Halt  (* to be raised to stop execution *)

(* the callback function is used to observe the execution
   trace; it can raise Hold to stop execution. Otherwise
   the processor never halts. *)
val execute: (status -> unit) -> status -> status

val fetch: Physical.WordMap.map -> word -> ASM.instruction * word * int