src/Pure/Admin/build_polyml.scala

     root: Path,
     sha1_root: Option[Path] = None,
     progress: Progress = new Progress,
     arch_64: Boolean = false,
     options: List[String] = Nil,
-    msys_root: Option[Path] = None)
+    mingw: MinGW = MinGW.none)
   {
     if (!((root + Path.explode("configure")).is_file && (root + Path.explode("PolyML")).is_dir))
       error("Bad Poly/ML root directory: " + root)
 
     val platform = Isabelle_Platform.self

     val info =
       platform_info.getOrElse(platform.os_name,
         error("Bad OS platform: " + quote(platform.os_name)))
 
     val settings =
-      msys_root match {
-        case None if platform.is_windows =>
-          error("Windows requires specification of msys root directory")
-        case None => Isabelle_System.settings()
-        case Some(msys) => Isabelle_System.settings() + ("MSYS" -> msys.expand.implode)
-      }
+      if (!Platform.is_windows) Isabelle_System.settings()
+      else Isabelle_System.settings() + ("MSYS" -> mingw.get_root.expand.implode)
 
     if (platform.is_linux && !Isabelle_System.bash("chrpath -v").ok) {
       error("""Missing "chrpath" executable on Linux""")
     }
 

     /* bash */
 
     def bash(
       cwd: Path, script: String, redirect: Boolean = false, echo: Boolean = false): Process_Result =
     {
-      val script1 =
-        msys_root match {
-          case None => script
-          case Some(msys) =>
-            File.bash_path(msys + Path.explode("usr/bin/bash")) + " -c " + Bash.string(script)
-        }
-      progress.bash(script1, cwd = cwd.file, redirect = redirect, echo = echo)
+      progress.bash(mingw.bash_script(script), cwd = cwd.file, redirect = redirect, echo = echo)
     }
 
 
     /* configure and make */
 

   /** Isabelle tool wrappers **/
 
   val isabelle_tool1 =
     Isabelle_Tool("build_polyml", "build Poly/ML from sources", args =>
     {
-      var msys_root: Option[Path] = None
+      var mingw = MinGW.none
       var arch_64 = Isabelle_Platform.self.is_arm
       var sha1_root: Option[Path] = None
 
       val getopts = Getopts("""
 Usage: isabelle build_polyml [OPTIONS] ROOT [CONFIGURE_OPTIONS]
 
   Options are:
-    -M DIR       msys root directory (for Windows)
+    -M DIR       msys/mingw root specification for Windows
     -m ARCH      processor architecture (32 or 64, default: """ +
         (if (arch_64) "64" else "32") + """)
     -s DIR       sha1 sources, see https://isabelle.sketis.net/repos/sha1
 
   Build Poly/ML in the ROOT directory of its sources, with additional
   CONFIGURE_OPTIONS (e.g. --without-gmp).
 """,
-        "M:" -> (arg => msys_root = Some(Path.explode(arg))),
+        "M:" -> (arg => mingw = MinGW.root(Path.explode(arg))),
         "m:" ->
           {
             case "32" => arch_64 = false
             case "64" => arch_64 = true
             case bad => error("Bad processor architecture: " + quote(bad))

         more_args match {
           case root :: options => (Path.explode(root), options)
           case Nil => getopts.usage()
         }
       build_polyml(root, sha1_root = sha1_root, progress = new Console_Progress,
-        arch_64 = arch_64, options = options, msys_root = msys_root)
+        arch_64 = arch_64, options = options, mingw = mingw)
     })
 
   val isabelle_tool2 =
     Isabelle_Tool("build_polyml_component", "make skeleton for Poly/ML component", args =>
     {