src/Pure/Admin/build_release.scala

     Isabelle_System.gnutar(args, dir = dir).check
 
 
   /* build heaps on remote server */
 
-  def remote_build_heaps(
-    options: Options, family: Platform.Family.Value, local_dir: Path, build_sessions: List[String])
-  {
-    val server_option = "build_release_server_" + family.toString
+  private def remote_build_heaps(
+    options: Options,
+    platform: Platform.Family.Value,
+    build_sessions: List[String],
+    local_dir: Path)
+  {
+    val server_option = "build_release_server_" + platform.toString
     options.string(server_option) match {
       case SSH.Target(user, host) =>
         using(SSH.open_session(options, host = host, user = user))(ssh =>
         {
           Isabelle_System.with_tmp_file("tmp", "tar")(local_tmp_tar =>

     official_release: Boolean = false,
     proper_release_name: Option[String] = None,
     platform_families: List[Platform.Family.Value] = default_platform_families,
     more_components: List[Path] = Nil,
     website: Option[Path] = None,
+    build_sessions: List[String] = Nil,
     build_library: Boolean = false,
     parallel_jobs: Int = 1): Release =
   {
     val hg = Mercurial.repository(Path.explode("$ISABELLE_HOME"))
 

             }
           }) ::: List(Path.explode("src/Tools/jEdit/dist/jedit.jar"))
         }
 
         val jedit_props = Path.explode("src/Tools/jEdit/dist/properties/jEdit.props")
+
+
+        // build heaps
+
+        if (build_sessions.nonEmpty) {
+          progress.echo("Building " + commas(build_sessions) + " ...")
+          remote_build_heaps(options, platform, build_sessions, isabelle_target)
+        }
 
 
         // application bundling
 
         platform match {

       var afp_rev = ""
       var components_base: Path = Components.default_components_base
       var official_release = false
       var proper_release_name: Option[String] = None
       var website: Option[Path] = None
+      var build_sessions: List[String] = Nil
       var more_components: List[Path] = Nil
       var parallel_jobs = 1
       var build_library = false
       var options = Options.init()
       var platform_families = default_platform_families

     -C DIR       base directory for Isabelle components (default: """ +
         Components.default_components_base + """)
     -O           official release (not release-candidate)
     -R RELEASE   proper release with name
     -W WEBSITE   produce minimal website in given directory
+    -b SESSIONS  build platform-specific session images (separated by commas)
     -c ARCHIVE   clean bundling with additional component .tar.gz archive
     -j INT       maximum number of parallel jobs (default 1)
     -l           build library
     -o OPTION    override Isabelle system OPTION (via NAME=VAL or NAME)
     -p NAMES     platform families (default: """ + default_platform_families.mkString(",") + """)

         "A:" -> (arg => afp_rev = arg),
         "C:" -> (arg => components_base = Path.explode(arg)),
         "O" -> (_ => official_release = true),
         "R:" -> (arg => proper_release_name = Some(arg)),
         "W:" -> (arg => website = Some(Path.explode(arg))),
+        "b:" -> (arg => build_sessions = space_explode(',', arg)),
         "c:" -> (arg =>
           {
             val path = Path.explode(arg)
             Components.Archive.get_name(path.file_name)
             more_components = more_components ::: List(path)

         progress = progress, rev = rev, afp_rev = afp_rev, official_release = official_release,
         proper_release_name = proper_release_name, website = website,
         platform_families =
           if (platform_families.isEmpty) default_platform_families
           else platform_families,
-        more_components = more_components, build_library = build_library,
-        parallel_jobs = parallel_jobs)
+        more_components = more_components, build_sessions = build_sessions,
+        build_library = build_library, parallel_jobs = parallel_jobs)
     }
   }
 }