use ocamlformat 0.28.1

Author: PerfectLaugh

.ocamlformat

@@ -1,2 +1,2 @@
 profile = default
-version = 0.27.0
+version = 0.28.1

lib/arm/arm_target.ml

@@ -639,12 +639,10 @@ module Encodings = struct
   let symbols_encoding spec =
     symbol_values spec
     |> Seq.fold ~init:empty ~f:(fun symbols (addr, value) ->
-           let addr = Bitvec.M32.int64 addr in
-           if is_thumb value then Map.set symbols ~key:addr ~data:llvm_t32
-           else
-             Map.update symbols addr ~f:(function
-               | None -> llvm_a32
-               | Some t -> t))
+        let addr = Bitvec.M32.int64 addr in
+        if is_thumb value then Map.set symbols ~key:addr ~data:llvm_t32
+        else
+          Map.update symbols addr ~f:(function None -> llvm_a32 | Some t -> t))
 
   let slot =
     KB.Class.property CT.Unit.cls ~package "symbols-encodings"

lib/arm/arm_utils.ml

@@ -75,9 +75,9 @@ let exec (stmts : stmt list) ?(flags : stmt list option) ?(wflag : op option)
       let cond = Bil.var cvar in
       Bil.(cvar := cval)
       :: List.map stmts ~f:(function
-           | Bil.Move (v, _) as s when Var.is_virtual v -> s
-           | Bil.Move (v, x) -> Bil.(v := ite ~if_:cond ~then_:x ~else_:(var v))
-           | _ -> assert false)
+        | Bil.Move (v, _) as s when Var.is_virtual v -> s
+        | Bil.Move (v, x) -> Bil.(v := ite ~if_:cond ~then_:x ~else_:(var v))
+        | _ -> assert false)
   | _ -> [ Bil.If (set_cond cond, stmts, []) ]
 
 let exp_of_reg reg = Bil.var (Env.of_reg reg)

lib/bap/bap.mli

@@ -441,8 +441,8 @@ module Std : sig
         let print_sections p =
           Project.memory p |> Memmap.to_sequence
           |> Seq.iter ~f:(fun (mem, x) ->
-                 Option.iter (Value.get Image.section x) ~f:(fun name ->
-                     printf "Section: %s@.%a@." name Memory.pp mem))
+              Option.iter (Value.get Image.section x) ~f:(fun name ->
+                  printf "Section: %s@.%a@." name Memory.pp mem))
 
         let () = Project.register_pass' print_sections
       ]}
@@ -10828,9 +10828,8 @@ module Std : sig
             report_progress ~task:"discover" ~total:(Term.length sub_t prog) ();
             Term.enum sub_t prog
             |> Seq.concat_mapi ~f:(fun stage sub ->
-                   report_progress ~note:(Sub.name sub) ~task:"discover" ~stage
-                     ();
-                   interesting_points_of_sub sub)
+                report_progress ~note:(Sub.name sub) ~task:"discover" ~stage ();
+                interesting_points_of_sub sub)
 
           let check_interesting_points points =
             report_progress ~task:"checking" ~total:(Seq.length points) ();

lib/bap/bap_project.ml

@@ -256,7 +256,7 @@ module Input = struct
   let dedup xs =
     List.rev @@ fst
     @@ List.fold xs ~init:([], String.Set.empty) ~f:(fun (xs, mems) x ->
-           if Set.mem mems x then (xs, mems) else (x :: xs, Set.add mems x))
+        if Set.mem mems x then (xs, mems) else (x :: xs, Set.add mems x))
 
   let provide_bias = Toplevel.var "provide-bias"
 
@@ -470,7 +470,7 @@ let compute_unit ?package ?state input =
         if KB.Domain.is_empty (KB.Slot.domain State.slot) state then
           Memmap.to_sequence code |> Seq.to_list_rev
           |> KB.List.fold ~init:State.empty ~f:(fun k (mem, _) ->
-                 State.disassemble k mem)
+              State.disassemble k mem)
           >>= State.partition
           >>= fun state ->
           KB.provide State.slot unit state >>| fun () -> state
@@ -588,9 +588,7 @@ let substitute project mem tag value : t =
   let find_tag tag mem =
     Memmap.dominators (memory project) mem
     |> Seq.find_map ~f:(fun (mem, v) ->
-           match Value.get tag v with
-           | Some reg -> Some (mem, reg)
-           | None -> None)
+        match Value.get tag v with Some reg -> Some (mem, reg) | None -> None)
   in
   let find_section = find_tag Image.section in
   let find_symbol mem =
@@ -601,10 +599,10 @@ let substitute project mem tag value : t =
   let find_block mem =
     Symtab.dominators (symbols project) mem
     |> List.find_map ~f:(fun (_, _, cfg) ->
-           Seq.find_map (Cfg.nodes cfg) ~f:(fun block ->
-               if Addr.(Block.addr block = Memory.min_addr mem) then
-                 Some (Block.memory block, block)
-               else None))
+        Seq.find_map (Cfg.nodes cfg) ~f:(fun block ->
+            if Addr.(Block.addr block = Memory.min_addr mem) then
+              Some (Block.memory block, block)
+            else None))
   in
   let subst_section (mem, name) = function
     | #bound as b -> addr b mem

lib/bap/bap_self.ml

@@ -97,9 +97,9 @@ module Create () = struct
       Configuration.parameters ~doc ?as_flag ?aliases:synonyms t name
       |> Configuration.determined
       |> Future.map ~f:(fun res ->
-             match default with
-             | None -> res
-             | Some default -> ( match res with [] -> default | xs -> xs))
+          match default with
+          | None -> res
+          | Some default -> ( match res with [] -> default | xs -> xs))
 
     let flag ?deprecated ?docv:_ ?(doc = "Undocumented.") ?synonyms name =
       let doc = prepend_deprecation deprecated doc in

lib/bap_build/bap_build.ml

@@ -138,8 +138,8 @@ module Plugin_rules = struct
   let generate_plugins_for_packages () =
     packages ()
     |> concat_map ~f:(fun name ->
-           concat_map [ `native; `byte ] ~f:(fun code ->
-               generate_plugin_for_package code name))
+        concat_map [ `native; `byte ] ~f:(fun code ->
+            generate_plugin_for_package code name))
 
   let make_list_option option = function
     | [] -> N
@@ -151,12 +151,10 @@ module Plugin_rules = struct
     let requires =
       packages ()
       |> concat_map ~f:(fun pkg ->
-             findlibs ~dynamic:false pkg
-             |> List.map ~f:(fun path ->
-                    let name =
-                      path |> Filename.chop_extension |> Filename.basename
-                    in
-                    name ^ "=" ^ name ^ ".cmxs," ^ name ^ "=" ^ name ^ ".cma"))
+          findlibs ~dynamic:false pkg
+          |> List.map ~f:(fun path ->
+              let name = path |> Filename.chop_extension |> Filename.basename in
+              name ^ "=" ^ name ^ ".cmxs," ^ name ^ "=" ^ name ^ ".cma"))
       |> make_list_option "-requires"
     in
     let provides =

lib/bap_bundle/bap_bundle.ml

@@ -162,31 +162,31 @@ module Std = struct
       b >>> fun zip ->
       Zip.entries zip
       |> List.filter_map ~f:(fun e ->
-             let name = Zip.(e.filename) in
-             Option.some_if (not (String.equal name Nameof.manifest)) name)
+          let name = Zip.(e.filename) in
+          Option.some_if (not (String.equal name Nameof.manifest)) name)
 
     let transform files bundle ~f =
       let zin = open_in bundle.path in
       let store filename data = Hashtbl.set files ~key:filename ~data in
       Zip.entries zin
       |> List.iter ~f:(fun entry ->
-             let filename = Zip.(entry.filename) in
-             let process_file f =
-               let name, chan = Filename.open_temp_file "bundle" "entry" in
-               Zip.copy_entry_to_channel zin entry chan;
-               Out_channel.close chan;
-               f name;
-               store filename (`Move name)
-             in
-             let process_data f =
-               let data = Zip.read_entry zin entry in
-               store filename (`Data (f data))
-             in
-             match f filename with
-             | `Map f -> process_data f
-             | `Proc f -> process_file f
-             | `Copy -> process_file ignore
-             | `Drop -> ());
+          let filename = Zip.(entry.filename) in
+          let process_file f =
+            let name, chan = Filename.open_temp_file "bundle" "entry" in
+            Zip.copy_entry_to_channel zin entry chan;
+            Out_channel.close chan;
+            f name;
+            store filename (`Move name)
+          in
+          let process_data f =
+            let data = Zip.read_entry zin entry in
+            store filename (`Data (f data))
+          in
+          match f filename with
+          | `Map f -> process_data f
+          | `Proc f -> process_file f
+          | `Copy -> process_file ignore
+          | `Drop -> ());
       Zip.close_in zin;
       let zout = Zip.open_out bundle.path in
       Hashtbl.iteri files ~f:(fun ~key:name ~data ->

lib/bap_byteweight/bap_byteweight_signatures.ml

@@ -74,8 +74,8 @@ let default_paths = [ default_path; system_path ]
 let try_lookup ?(paths = []) ?compiler target data =
   paths @ default_paths
   |> List.find_map ~f:(fun path ->
-         if Sys.file_exists path then read_entry ?compiler target data path
-         else None)
+      if Sys.file_exists path then read_entry ?compiler target data path
+      else None)
 
 let of_exn = function
   | Sys_error msg -> Error (`Sys_error msg)
@@ -93,7 +93,7 @@ let update_or_fail ?compiler target data payload path =
   let entries =
     read_entries path
     |> List.filter ~f:(fun (entry, _) ->
-           not (matching_entry ?compiler target data entry))
+        not (matching_entry ?compiler target data entry))
   in
   with_output path @@ fun zip ->
   let path = make_entry ?compiler target data in

lib/bap_c/bap_c_abi.ml

@@ -425,9 +425,9 @@ module Arg = struct
     let slots stack =
       Map.to_alist stack.data
       |> List.filter_map ~f:(fun (off, (info, bits)) ->
-             match info with
-             | None -> None
-             | Some { datum } -> Some (off, datum, bits))
+          match info with
+          | None -> None
+          | Some { datum } -> Some (off, datum, bits))
 
     let singleton entry stack =
       { stack with data = Map.singleton (module Int) 0 entry }
@@ -793,7 +793,7 @@ module Arg = struct
               let base = Stack.base stack in
               Stack.slots stack
               |> List.map ~f:(fun (off, data, bits) ->
-                     (data, load target bits base off))
+                  (data, load target bits base off))
         in
         Some
           {