Put Host on Exa type

lib/Common.ml

···
   | TEST_LT of r_n * r_n
   | TEST_GT of r_n * r_n
   (* Movement *)
-  (*| HOST of register*)
+  | HOST of register
   (* File Manipulation *)
   | MAKE
   | GRAB of r_n
···
   code : op_code Dynarray.t;
   mutable ip : int;
   labels : (string, int) Hashtbl.t;
-  mutable host_name : string;
+  mutable host : host;
 }
 
 and host = {

lib/Debugger.ml

···
   | None -> ()
   | Some exa ->
       if not exa.dead then (
-        Printf.printf "== %s (%s) ==\n" exa.name exa.host_name;
+        Printf.printf "== %s (%s) ==\n" exa.name exa.host.name;
         Printf.printf "X: %s\n" (Value.show exa.x);
         Printf.printf "T: %s\n" (Value.show exa.t);
         Printf.printf "F: %s\n"

lib/Exa.ml

···
    License, v. 2.0. If a copy of the MPL was not distributed with this
    file, You can obtain one at https://mozilla.org/MPL/2.0/. *)
 
+open Common
 type t = Common.exa
 
-let create ?(code = Dynarray.create ()) (name : string) (host_name : string) : t =
+let create ?(code = Dynarray.create ()) (name : string) (host : host) : t =
   {
     name;
     dead = false;
···
     code;
     ip = 0;
     labels = Hashtbl.create 0;
-    host_name;
+    host;
   }
 
 let length (exa : t) = Dynarray.length exa.code [@@inline always]

lib/OpCode.ml

···
   | TEST_EQ (left, right) -> testInstruction "TEST" left "=" right
   | TEST_LT (left, right) -> testInstruction "TEST" left "<" right
   | TEST_GT (left, right) -> testInstruction "TEST" left ">" right
-  (*| HOST dest -> regInstruction "HOST" dest*)
+  | HOST dest -> regInstruction "HOST" dest
   | MAKE -> "MAKE"
   | GRAB file -> rnInstruction "GRAB" file
   | FILE dest -> regInstruction "FILE" dest
···
   | TEST_LT _, _
   | TEST_GT _, _ ->
       false
-  (*| HOST r1, HOST r2 -> Register.equal r1 r2*)
-  (*| HOST _, _ -> false*)
+  | HOST r1, HOST r2 -> Register.equal r1 r2
+  | HOST _, _ -> false
   | MAKE, MAKE -> true
   | MAKE, _ -> false
   | GRAB f1, GRAB f2 -> Register.equal_r_n f1 f2

lib/Vm.ml

···
 let place_exa (vm : t) (host : Host.t) (exa : Exa.t) : unit =
   if Host.add host (E exa) then (
     Dynarray.add_last vm.exas (Some exa);
-    exa.host_name <- host.name)
+    exa.host <- host)
 
 let create_exa (vm : t) (host : Host.t) (name : string) (code : string) :
     (Exa.t, string) result =
   Result.bind (Reader.parse_code code) (fun code ->
-      let exa = Exa.create name host.name ~code in
+      let exa = Exa.create name host ~code in
       place_exa vm host exa;
       Ok exa)
 
···
 
 let get_host (vm : t) (hostname : string) = StringMap.find_opt vm.hosts hostname
 
-let get_file (vm : t) (hostname : string) (filename : string) =
-  Option.bind (get_host vm hostname) (fun host -> Host.find_file host filename)
+let get_file (host : host) (filename : string) = Host.find_file host filename
 
 (** FILE OPS **)
 
···
   | Key s -> Key s
 [@@inline always]
 
-let math_fn (exa : Exa.t) func (src : r_n) (i : r_n) (dest : register) :
-    inst_result =
+let math_fn (exa : Exa.t) func (src : r_n) (i : r_n) (dest : register) : inst_result =
   let left = value_of_r_n exa src in
   let right = value_of_r_n exa i in
   match (left, right) with
···
       add_file vm file;
       pass ()
 
-let grab (vm : t) (exa : Exa.t) (src : Register.r_n) : inst_result =
+let host (_vm : t) (_exa : Exa.t) (_dest : register) : inst_result = pass ()
+
+let grab (exa : Exa.t) (src : r_n) : inst_result =
   match value_of_r_n exa src with
   | Error _ as e -> e
   | Ok value -> (
···
         | Int i -> string_of_int i
         | Key k -> k
       in
-      match get_file vm exa.host_name filename with
+      match get_file exa.host filename with
       | None -> runtime_error "NO FILE TO GRAB"
       | Some file ->
-          (match get_host vm exa.host_name with
-          | None -> ()
-          | Some host -> Host.remove host filename);
+          Host.remove exa.host filename;
           exa.f <- Some file;
           exa.f_pos <- 0;
           pass ())
···
       end
   | Some _, _ -> runtime_error "WRONG REGISTER"
 
-let drop (vm : t) (exa : Exa.t) : inst_result =
+let drop (exa : Exa.t) : inst_result =
   match exa.f with
   | None -> runtime_error "NO CURRENT FILE"
   | Some file ->
       if
-        match get_host vm exa.host_name with
-        | None -> false
-        | Some host -> Host.add host (F file)
+        Host.add exa.host (F file)
       then (
         exa.f <- None;
         exa.f_pos <- 0;
···
       | TEST_EQ (left, right) -> test_fn exa left test_eq right
       | TEST_LT (left, right) -> test_fn exa left test_lt right
       | TEST_GT (left, right) -> test_fn exa left test_gt right
+      | HOST dest -> host vm exa dest
       | MAKE -> make vm exa
-      | GRAB id -> grab vm exa id
+      | GRAB id -> grab exa id
       | FILE dest -> fname exa dest
       | SEEK value -> seek exa value
       | VOID_F -> void exa F
-      | DROP -> drop vm exa
+      | DROP -> drop exa
       | WIPE -> wipe vm exa
       | TEST_EOF -> test_eof exa)
 
···
     | None -> i := !i + 1
     | Some exa -> (
         if exa.dead then
-          let _ = drop vm exa in
+          let _ = drop exa in
           Dynarray.set vm.exas !i None
         else
           let ret = execute vm exa in