diff --git a/ocamlbuild/command.ml b/ocamlbuild/command.ml
index 131cd85..c2791fb 100644
--- a/ocamlbuild/command.ml
+++ b/ocamlbuild/command.ml
@@ -91,9 +91,15 @@ let atomize_paths l = S(List.map (fun x -> P x) l)
 
 let env_path = lazy begin
   let path_var = Sys.getenv "PATH" in
+  let parse_path =
+    if Sys.os_type = "Win32" then
+      Lexers.parse_environment_path_w
+    else
+      Lexers.parse_environment_path
+  in
   let paths =
     try
-      Lexers.parse_environment_path (Lexing.from_string path_var)
+      parse_path (Lexing.from_string path_var)
     with Lexers.Error msg -> raise (Lexers.Error ("$PATH: " ^ msg))
   in
   let norm_current_dir_name path =
@@ -120,13 +126,21 @@ let virtual_solver virtual_command =
                               has failed finding a valid command" virtual_command)
 
 
-(* FIXME windows *)
 let search_in_path cmd =
+  (* Try to find [cmd] in path [path]. *)
+  let try_path path =
+    (* On Windows, we need to also check for the ".exe" version of the file. *)
+    let exists file =
+      sys_file_exists file || Sys.os_type = "Win32" && sys_file_exists (file ^ ".exe")
+    in
+    (* Don't know why we're trying to be subtle here... *)
+    if path = Filename.current_dir_name then exists cmd
+    else exists (filename_concat path cmd)
+  in
   if Filename.is_implicit cmd then
-    let path = List.find begin fun path ->
-      if path = Filename.current_dir_name then sys_file_exists cmd
-      else sys_file_exists (filename_concat path cmd)
-    end !*env_path in
+    let path = List.find try_path !*env_path in
+    (* We're not trying to append ".exe" here because all windows shells are
+     * capable of understanding the command without the ".exe" suffix. *)
     filename_concat path cmd
   else cmd
 
diff --git a/ocamlbuild/lexers.mli b/ocamlbuild/lexers.mli
index 2f37edc..bc5de4c 100644
--- a/ocamlbuild/lexers.mli
+++ b/ocamlbuild/lexers.mli
@@ -32,6 +32,8 @@ val trim_blanks : Lexing.lexbuf -> string
    Example:
       ":aaa:bbb:::ccc:" -> [""; "aaa"; "bbb"; ""; ""; "ccc"; ""] *)
 val parse_environment_path : Lexing.lexbuf -> string list
+(* Same one, for Windows (PATH is ;-separated) *)
+val parse_environment_path_w : Lexing.lexbuf -> string list
 
 val conf_lines : string option -> int -> string -> Lexing.lexbuf -> conf
 val path_scheme : bool -> Lexing.lexbuf ->
diff --git a/ocamlbuild/lexers.mll b/ocamlbuild/lexers.mll
index 7b191b0..2206f86 100644
--- a/ocamlbuild/lexers.mll
+++ b/ocamlbuild/lexers.mll
@@ -81,6 +81,15 @@ and comma_or_blank_sep_strings_aux = parse
   | space* eof { [] }
   | _ { raise (Error "Expecting (comma|blank)-separated strings (2)") }
 
+and parse_environment_path_w = parse
+  | ([^ ';']* as word) { word :: parse_environment_path_aux_w lexbuf }
+  | ';' ([^ ';']* as word) { "" :: word :: parse_environment_path_aux_w lexbuf }
+  | eof { [] }
+and parse_environment_path_aux_w = parse
+  | ';' ([^ ';']* as word) { word :: parse_environment_path_aux_w lexbuf }
+  | eof { [] }
+  | _ { raise (Error "Impossible: expecting colon-separated strings") }
+
 and parse_environment_path = parse
   | ([^ ':']* as word) { word :: parse_environment_path_aux lexbuf }
   | ':' ([^ ':']* as word) { "" :: word :: parse_environment_path_aux lexbuf }
diff --git a/ocamlbuild/my_std.ml b/ocamlbuild/my_std.ml
index 78286b5..4fdc6bf 100644
--- a/ocamlbuild/my_std.ml
+++ b/ocamlbuild/my_std.ml
@@ -257,10 +257,11 @@ let sys_command =
 (* FIXME warning fix and use Filename.concat *)
 let filename_concat x y =
   if x = Filename.current_dir_name || x = "" then y else
-  if x.[String.length x - 1] = '/' then
+  if Sys.os_type = "Win32" && (x.[String.length x - 1] = '\\') || x.[String.length x - 1] = '/' then
     if y = "" then x
     else x ^ y
-  else x ^ "/" ^ y
+  else
+    x ^ "/" ^ y
 
 (* let reslash =
   match Sys.os_type with

From 776f73d7d72bbd3e4706c2527ae7051d77f01094 Mon Sep 17 00:00:00 2001
From: Gabriel Scherer <gabriel.scherer@inria.fr>
Date: Mon, 2 Apr 2012 10:21:10 +0200
Subject: [PATCH] [PR#5435] search_in_path return the exact filepath found,
 including .exe

This patch is built on top of Jonathan Protzenko's first patch. For
implementation reasons it was easier to find the correct directory
path without returning which of ".opt" or ".opt.exe" version were
found. This patch introduces a new
  find_opt : ('a -> 'b option) -> 'a -> 'b
function in my_std.ml to makes this hurdle go away.

The subtlety about (path = current_dir_name) is still present, and
poisons the code clarity. It would be nice to know for sure why it's
there or if it can be removed.
---
 ocamlbuild/command.ml     |   32 +++++++++++++++++++-------------
 ocamlbuild/my_std.ml      |   11 +++++++++++
 ocamlbuild/signatures.mli |    2 ++
 3 files changed, 32 insertions(+), 13 deletions(-)

diff --git a/ocamlbuild/command.ml b/ocamlbuild/command.ml
index c2791fb..7a91ea1 100644
--- a/ocamlbuild/command.ml
+++ b/ocamlbuild/command.ml
@@ -129,20 +129,26 @@ let virtual_solver virtual_command =
 let search_in_path cmd =
   (* Try to find [cmd] in path [path]. *)
   let try_path path =
-    (* On Windows, we need to also check for the ".exe" version of the file. *)
-    let exists file =
-      sys_file_exists file || Sys.os_type = "Win32" && sys_file_exists (file ^ ".exe")
-    in
-    (* Don't know why we're trying to be subtle here... *)
-    if path = Filename.current_dir_name then exists cmd
-    else exists (filename_concat path cmd)
+    let try_file file =
+      if sys_file_exists file then Some file
+      else
+        (* On Windows, we need to also check for the ".exe" version of the file. *)
+        if Sys.os_type <> "Win32" then None
+        else
+          let file_exe = file ^ ".exe" in
+          if sys_file_exists file_exe then Some file_exe else None in
+    (* The original code ensured that, when path = current_dir_name,
+       file_exists is called with a relative path; but the results are
+       still given as absolute path (hence the opt_map). We don't know
+       why this subtlety, but it can't hurt being careful. *)
+    if path = Filename.current_dir_name
+    then opt_map (filename_concat path) (try_file cmd)
+    else try_file (filename_concat path cmd)
   in
-  if Filename.is_implicit cmd then
-    let path = List.find try_path !*env_path in
-    (* We're not trying to append ".exe" here because all windows shells are
-     * capable of understanding the command without the ".exe" suffix. *)
-    filename_concat path cmd
-  else cmd
+  if not (Filename.is_implicit cmd) then cmd
+  else 
+    (* My_std.List.find_opt : ('a -> 'b option) -> 'a -> 'b, raise Not_found *)
+    List.find_opt try_path !*env_path
 
 (*** string_of_command_spec{,_with_calls *)
 let rec string_of_command_spec_with_calls call_with_tags call_with_target resolve_virtuals spec =
diff --git a/ocamlbuild/my_std.ml b/ocamlbuild/my_std.ml
index 4fdc6bf..5cc8edc 100644
--- a/ocamlbuild/my_std.ml
+++ b/ocamlbuild/my_std.ml
@@ -44,6 +44,10 @@ let opt_print elt ppf =
   | Some x -> fprintf ppf "@[<2>Some@ %a@]" elt x
   | None -> pp_print_string ppf "None"
 
+let opt_map f = function
+  | Some x -> Some (f x)
+  | None -> None
+
 open Format
 let ksbprintf g fmt =
   let buff = Buffer.create 42 in
@@ -119,6 +123,13 @@ module List = struct
   let union a b =
     rev (rev_append_uniq (rev_append_uniq [] a) b)
 
+  (* we don't return an option for consistency with List.find *)
+  let rec find_opt f = function
+    | [] -> raise Not_found
+    | x :: xs ->
+      match f x with
+        | Some result -> result
+        | None -> find_opt f xs
 end
 
 module String = struct
diff --git a/ocamlbuild/signatures.mli b/ocamlbuild/signatures.mli
index 91dc6c6..8be1a9a 100644
--- a/ocamlbuild/signatures.mli
+++ b/ocamlbuild/signatures.mli
@@ -33,6 +33,7 @@ module type LIST = sig
   val print : (Format.formatter -> 'a -> 'b) -> Format.formatter -> 'a list -> unit
   val filter_opt : ('a -> 'b option) -> 'a list -> 'b list
   val union : 'a list -> 'a list -> 'a list
+  val find_opt : ('a -> 'b option) -> 'a list -> 'b
 
   (* Original functions *)
   include module type of List
@@ -319,6 +320,7 @@ end
 module type MISC = sig
   val opt_print :
     (Format.formatter -> 'a -> unit) -> Format.formatter -> 'a option -> unit
+  val opt_map : ('a -> 'b) -> 'a option -> 'b option
   val the : 'a option -> 'a
   val getenv : ?default:string -> string -> string
   val with_input_file : ?bin:bool -> string -> (in_channel -> 'a) -> 'a
-- 
1.7.7.3