Fsc tool

Author: OlegZee

build.fsx

@@ -0,0 +1,102 @@
+// xake build file
+#r @"bin/Debug/Xake.Core.dll"
+
+open Xake
+
+let fsc = """C:\Program Files (x86)\Microsoft SDKs\F#\3.0\Framework\v4.0\fsc.exe"""
+
+do xake {XakeOptions with FileLog = "build.log"; ConLogLevel = Verbosity.Chatty } {
+
+    rules [
+        "main"  <== ["build"]
+        "build" <== ["bin/Xake.Core.dll"]
+
+        "clean" => action {
+            do! rm ["bin/Xake.Core.dll"]
+        }
+
+        "bin/Xake.Core.dll" *> fun file -> action {
+
+            // TODO --doc:..\bin\Xake.Core.XML --- multitarget rule!
+            
+            let sources = fileset {
+                basedir "core"
+                includes "Logging.fs"
+                includes "Pickler.fs"
+                includes "Fileset.fs"
+                includes "Types.fs"
+                includes "ArtifactUtil.fs"
+                includes "CommonLib.fs"
+                includes "Database.fs"
+                includes "Action.fs"
+                includes "WorkerPool.fs"
+                includes "Progress.fs"
+                includes "XakeScript.fs"
+                includes "CommonTasks.fs"
+                includes "FileTasks.fs"
+                includes "ResourceFileset.fs"
+                includes "DotNetFwk.fs"
+                includes "DotnetTasks.fs"
+                includes "VersionInfo.fs"
+                includes "AssemblyInfo.fs"
+                includes "Program.fs"
+            }
+
+            let! options = getCtxOptions()
+            let getFiles = toFileList options.ProjectRoot
+
+            let (Filelist sourceFiles) = sources |> toFileList options.ProjectRoot
+
+            do! needFiles (Filelist sourceFiles)
+
+            let (settings,files,refs) =
+                (
+                    ["--target:library"; "--define:TRACE"; "--optimize+"; "--warn:3"; "--warnaserror:76"; "--utf8output"],
+                    ["Logging.fs"; "Pickler.fs"; "Fileset.fs"; "Types.fs"; "ArtifactUtil.fs"; "CommonLib.fs"; "Database.fs"; "Action.fs"; "WorkerPool.fs"; "Progress.fs"; "XakeScript.fs"; "CommonTasks.fs"; "FileTasks.fs"; "ResourceFileset.fs"; "DotNetFwk.fs"; "DotnetTasks.fs"; "VersionInfo.fs"; "AssemblyInfo.fs"; "Program.fs"],
+                    ["System.dll"; "System.Core.dll"; "System.Windows.Forms.dll"]
+                )
+
+            let! exitcode = system fsc <| ["-o:" + file.FullName; ""] @ settings @ (sourceFiles |> List.map (fun f -> f.FullName)) @ (refs |> List.map (fun n -> "/r:" + n))
+
+            do! writeLog Command "job done %A" exitcode
+        }
+
+        "bin/Xake.Core1.dll" *> fun file -> action {
+
+            // TODO --doc:..\bin\Xake.Core.XML --- multitarget rule!
+            
+            let sources = fileset {
+                basedir "core"
+                includes "Logging.fs"
+                includes "Pickler.fs"
+                includes "Fileset.fs"
+                includes "Types.fs"
+                includes "ArtifactUtil.fs"
+                includes "CommonLib.fs"
+                includes "Database.fs"
+                includes "Action.fs"
+                includes "WorkerPool.fs"
+                includes "Progress.fs"
+                includes "XakeScript.fs"
+                includes "CommonTasks.fs"
+                includes "FileTasks.fs"
+                includes "ResourceFileset.fs"
+                includes "DotNetFwk.fs"
+                includes "DotnetTasks.fs"
+                includes "VersionInfo.fs"
+                includes "AssemblyInfo.fs"
+                includes "Program.fs"
+            }
+
+            do! Fsc {
+                FscSettings with
+                    Out = file
+                    Src = sources
+                    RefGlobal = ["System.dll"; "System.Core.dll"; "System.Windows.Forms.dll"]
+                    Define = ["TRACE"]
+                }
+
+        }
+    ]
+
+}

core/CommonTasks.fs

@@ -91,6 +91,7 @@ let system cmd args =
     do! writeLog Info "[system] starting '%s'" cmd
     let! exitCode = _system SystemOptions cmd (args |> String.concat " ")
     do! writeLog Info "[system] сompleted '%s' exitcode: %d" cmd exitCode
+
     return exitCode
   }
 

core/DotNetFwk.fs

@@ -44,6 +44,7 @@ module DotNetFwk =
         AssemblyDirs: string list
         ToolDir: string
         CscTool: string
+        FscTool: string option
         MsbuildTool: string
         EnvVars: (string* string) list
         }
@@ -107,6 +108,7 @@ module DotNetFwk =
                         ToolDir = libdir </> "mono" </> libpath
                         Version = ver
                         CscTool = csc_tool
+                        FscTool = Some "fsharpi"
                         MsbuildTool = "xbuild"
                         EnvVars =["PATH", sdkroot </> "bin" + ";" + (%"PATH")]
                     }
@@ -124,6 +126,11 @@ module DotNetFwk =
     module internal MsImpl =
         open registry
 
+        let fscTool =
+            registry.open_subkey registry.HKLM @"SOFTWARE\Wow6432Node\Microsoft\FSharp\3.0\Runtime\v4.0"
+            |> Option.bind (registry.get_value_str "")
+            |> Option.bind (fun p -> System.IO.Path.Combine (p, "fsc.exe") |> Some)
+
         let tryLocateFwk fwk =
             let fwkKey = open_subkey HKLM @"SOFTWARE\Microsoft\.NETFramework"
             let installRoot_ = fwkKey |> Option.bind (get_value_str "InstallRoot")
@@ -163,6 +170,7 @@ module DotNetFwk =
                     Version = version
                     AssemblyDirs = asmpaths
                     CscTool = fwkdir </> "csc.exe"
+                    FscTool = fscTool
                     MsbuildTool = fwkdir </> "msbuild.exe"
                     EnvVars = vars
                 }, null

core/DotnetTasks.fs

@@ -74,14 +74,46 @@ module DotNetTaskTypes =
         FailOnError: bool
     }
 
+    /// <summary>
+    /// Fsc (F# compiler) task settings.
+    /// </summary>
+    type FscSettingsType = {
+        /// Limits which platforms this code can run on. The default is anycpu.
+        Platform: TargetPlatform
+        /// Specifies the format of the output file.
+        Target: TargetType
+        /// Specifies the output file name (default: base name of file with main class or first file).
+        Out: Artifact
+        /// Source files.
+        Src: Fileset
+        /// References metadata from the specified assembly files.
+        Ref: Fileset
+        /// References the specified assemblies from GAC.
+        RefGlobal: string list
+        /// Embeds the specified resource.
+        Resources: ResourceFileset list
+        /// Defines conditional compilation symbols.
+        Define: string list
+        /// Allows unsafe code.
+        Unsafe: bool
+        /// Target .NET framework
+        TargetFramework: string
+        /// Custom command-line arguments
+        CommandArgs: string list
+        /// Build fails on compile error.
+        FailOnError: bool
+
+        Tailcalls: bool
+    }
+
 [<AutoOpen>]
 module DotnetTasks =
 
     open CommonTasks.impl
 
     /// Default setting for CSC task so that you could only override required settings
     let CscSettings = {
-        Platform = AnyCpu
+        CscSettingsType.Platform = AnyCpu
         Target = Auto    // try to resolve the type from name etc
         Out = Artifact.Undefined
         Src = Fileset.Empty
@@ -96,6 +128,7 @@ module DotnetTasks =
     }
 
     module internal Impl =
+        begin
         /// Escapes argument according to CSC.exe rules (see http://msdn.microsoft.com/en-us/library/78f4aasd.aspx)
         let escapeArgument (str:string) =
             let escape c s =
@@ -179,24 +212,26 @@ module DotnetTasks =
                 (Path.ChangeExtension(res,".resources"),tempfile,true)
             | (res,file) ->
                 (res,file,false)
-    // end of Impl module
-
-    /// C# compiler task
-    let Csc settings =
-
-        let outFile = settings.Out
 
         let resolveTarget (name:string) =
             if name.EndsWith (".dll", System.StringComparison.OrdinalIgnoreCase) then Library else
             if name.EndsWith (".exe", System.StringComparison.OrdinalIgnoreCase) then Exe else
             Library
 
-        let rec targetStr = function
+        let rec targetStr fileName = function
             |AppContainerExe -> "appcontainerexe" |Exe -> "exe" |Library -> "library" |Module -> "module" |WinExe -> "winexe" |WinmdObj -> "winmdobj"
-            |Auto -> outFile.Name |> resolveTarget |> targetStr
+            |Auto -> fileName |> resolveTarget |> targetStr fileName
+
         let platformStr = function
             |AnyCpu -> "anycpu" |AnyCpu32Preferred -> "anycpu32preferred" |ARM -> "arm" | X64 -> "x64" | X86 -> "x86" |Itanium -> "itanium"
-        
+    
+        end // end of Impl module
+
+    /// C# compiler task
+    let Csc (settings:CscSettingsType) =
+
+        let outFile = settings.Out
+
         action {
             let! options = getCtxOptions()
             let getFiles = toFileList options.ProjectRoot
@@ -241,8 +276,8 @@ module DotnetTasks =
                 seq {
                     yield "/nologo"
 
-                    yield "/target:" + targetStr settings.Target
-                    yield "/platform:" + platformStr settings.Platform
+                    yield "/target:" + Impl.targetStr outFile.Name settings.Target
+                    yield "/platform:" + Impl.platformStr settings.Platform
 
                     if settings.Unsafe then
                         yield "/unsafe"
@@ -396,7 +431,7 @@ module DotnetTasks =
             let! dotnetFwk = getVar "NETFX"
             let fwkInfo = DotNetFwk.locateFramework dotnetFwk
 
-            let pfx = "msbuild" // TODO thread/index
+            let pfx = "msbuild"
 
             let verbosityKey = function | Quiet -> "q" | Minimal -> "m" | Normal -> "n" | Detailed -> "d" | Diag -> "diag"
 
@@ -443,3 +478,134 @@ module DotnetTasks =
                 if settings.FailOnError then failwithf "Exiting due to FailOnError set on '%s'" pfx
             ()
         }
+
+    /// <summary>
+    /// Default settings for Fsc task.
+    /// </summary>
+    let FscSettings = {
+        FscSettingsType.Platform = AnyCpu
+        FscSettingsType.Target = Auto
+        Out = Artifact.Undefined
+        Src = Fileset.Empty
+        Ref = Fileset.Empty
+        RefGlobal = []
+        Resources = []
+        Define = []
+        Unsafe = false
+        TargetFramework = null
+        CommandArgs = []
+        FailOnError = true
+
+        Tailcalls = true
+    }
+
+    /// F# compiler task
+    let Fsc (settings:FscSettingsType) =
+
+        let outFile = settings.Out
+
+        action {
+            let! options = getCtxOptions()
+            let getFiles = toFileList options.ProjectRoot
+
+            let resinfos = settings.Resources |> List.collect (Impl.collectResInfo options.ProjectRoot) |> List.map Impl.compileResxFiles
+            let resfiles =
+                List.ofSeq <|
+                query {
+                    for (_,file,istemp) in resinfos do
+                        where (not istemp)
+                        select (file)
+                }
+
+            let (Filelist src)  = settings.Src |> getFiles
+            let (Filelist refs) = settings.Ref |> getFiles
+
+            do! needFiles (Filelist (src @ refs @ resfiles))
+
+            // TODO implement support for targeting various frameworks
+            let! globalTargetFwk = getVar "NETFX-TARGET"
+            let targetFramework =
+                match settings.TargetFramework, globalTargetFwk with
+                | s, _ when s <> null && s <> "" -> s
+                | _, Some s when s <> "" -> s
+                | _ -> null
+
+            let (globalRefs,nostdlib,noconfig) =
+                match targetFramework with
+                | null ->
+                    let mapfn = (+) "/r:"
+                    // TODO provide an option for user to explicitly specify all grefs (currently csc.rsp is used)
+                    (settings.RefGlobal |> List.map mapfn), false, false
+                | tgt ->
+                    let fwk = Some tgt |> DotNetFwk.locateFramework in
+                    let lookup = DotNetFwk.locateAssembly fwk
+                    let mapfn = (fun name -> "/r:" + (lookup name))
+
+                    //do! writeLog Info "Using libraries from %A" fwk.AssemblyDirs
+
+                    ("mscorlib.dll" :: settings.RefGlobal |> List.map mapfn), true, true
+
+            let args =
+                seq {
+                    if noconfig then
+                        yield "/noconfig"
+                    yield "/nologo"
+
+                    yield "/target:" + Impl.targetStr outFile.Name settings.Target
+                    //yield "/platform:" + Impl.platformStr settings.Platform
+
+                    if settings.Unsafe then
+                        yield "/unsafe"
+
+                    if nostdlib then
+                        yield "/nostdlib+"
+
+                    if not outFile.IsUndefined then
+                        yield sprintf "/out:%s" outFile.FullName
+
+                    if not (List.isEmpty settings.Define) then
+                        yield "/define:" + (settings.Define |> String.concat ";")
+
+                    yield! src |> List.map (fun f -> f.FullName) 
+
+                    yield! refs |> List.map ((fun f -> f.FullName) >> (+) "/r:")
+                    yield! globalRefs
+
+                    yield! resinfos |> List.map (fun(name,file,_) -> sprintf "/res:%s,%s" file.FullName name)
+                    yield! settings.CommandArgs
+                }
+
+            let! dotnetFwk = getVar "NETFX"
+            let fwkInfo = DotNetFwk.locateFramework dotnetFwk
+
+            if Option.isNone fwkInfo.FscTool then
+                do! writeLog Error "('%s') failed: F# compiler not found" outFile.Name
+                if settings.FailOnError then failwithf "Exiting due to FailOnError set on '%s'" outFile.Name
+
+            let (Some fsc) = fwkInfo.FscTool                
+
+            do! writeLog Info "compiling '%s' using framework '%s'" outFile.Name fwkInfo.Version
+            do! writeLog Debug "Command line: '%s %s'" fsc (args |> Seq.map Impl.escapeArgument |> String.concat "\r\n\t")
+
+            let options = {
+                SystemOptions with
+                    LogPrefix = "[FSC] "
+                    StdOutLevel = Level.Verbose     // consider standard compiler output too noisy
+                    EnvVars = fwkInfo.EnvVars
+                }
+            let! exitCode = _system options fsc (args |> String.concat " ")
+
+            do! writeLog Level.Verbose "Deleting temporary files"
+            seq {
+                yield! query {
+                    for (_,file,istemp) in resinfos do
+                        where istemp
+                        select file.FullName
+                }
+            }
+            |> Seq.iter File.Delete
+
+            if exitCode <> 0 then
+                do! writeLog Error "('%s') failed with exit code '%i'" outFile.Name exitCode
+                if settings.FailOnError then failwithf "Exiting due to FailOnError set on '%s'" outFile.Name
+        }