public void StaticLibrary_LibraryPaths()
{
var arguments = new LinkArguments();
arguments.TargetType = LinkTarget.StaticLibrary;
arguments.TargetArchitecture = "x64";
arguments.TargetFile = new Path("Library.mock.lib");
arguments.ObjectFiles = new List <Path>()
{
new Path("File.mock.o"),
};
arguments.LibraryPaths = new List <Path>()
{
new Path("../libraries/"),
};
var actualArguments = ArgumentBuilder.BuildLinkerArguments(arguments);
var expectedArguments = new List <string>()
{
"/nologo",
"/machine:X64",
"/libpath:\"../libraries/\"",
"/out:\"./Library.mock.lib\"",
"./File.mock.o",
};
Assert.Equal(expectedArguments, actualArguments);
}
public void WindowsApplication()
{
var arguments = new LinkArguments();
arguments.TargetType = LinkTarget.WindowsApplication;
arguments.TargetArchitecture = "x64";
arguments.TargetFile = new Path("out/Something.exe");
arguments.ObjectFiles = new List <Path>()
{
new Path("File.mock.obj"),
};
arguments.LibraryFiles = new List <Path>()
{
new Path("Library.mock.lib"),
};
var actualArguments = ArgumentBuilder.BuildLinkerArguments(arguments);
var expectedArguments = new List <string>()
{
"/nologo",
"/subsystem:windows",
"/machine:X64",
"/out:\"./out/Something.exe\"",
"./Library.mock.lib",
"./File.mock.obj",
};
Assert.Equal(expectedArguments, actualArguments);
}
public void DynamicLibrary()
{
var arguments = new LinkArguments();
arguments.TargetType = LinkTarget.DynamicLibrary;
arguments.TargetArchitecture = "x64";
arguments.TargetFile = new Path("Library.mock.dll");
arguments.ImplementationFile = new Path("Library.mock.lib");
arguments.ObjectFiles = new List <Path>()
{
new Path("File.mock.obj"),
};
var actualArguments = ArgumentBuilder.BuildLinkerArguments(arguments);
var expectedArguments = new List <string>()
{
"/nologo",
"/subsystem:console",
"/dll",
"/implib:\"./Library.mock.lib\"",
"/machine:X64",
"/out:\"./Library.mock.dll\"",
"./File.mock.obj",
};
Assert.Equal(expectedArguments, actualArguments);
}
/// <summary>
/// Links the source with the other node.
/// </summary>
/// <param name="source"></param>
/// <param name="other"></param>
/// <returns>True if the link was applied.</returns>
public static bool ApplyLink(BehaviourNode source, BehaviourNode other)
{
var key = new LinkArguments(source.GetType(), other.GetType());
if (linkActions.TryGetValue(key, out LinkAction linker))
{
linker(source, other);
return(true);
}
return(false);
}
public void EmptyTargetFile_Throws()
{
var arguments = new LinkArguments();
arguments.TargetType = LinkTarget.StaticLibrary;
arguments.TargetFile = new Path("");
arguments.ObjectFiles = new List <Path>()
{
new Path("File.mock.obj"),
};
Assert.Throws <InvalidOperationException>(() => {
var actualArguments = ArgumentBuilder.BuildLinkerArguments(arguments);
});
}
/// <summary>
/// Link
/// </summary>
public BuildOperation CreateLinkOperation(LinkArguments arguments)
{
_linkRequests.Add(arguments);
return(new BuildOperation(
$"MockLink: {_linkRequests.Count}",
new Path("MockWorkingDirectory"),
new Path("MockLinker.exe"),
"Arguments",
new List <Path>()
{
new Path("InputFile.in"),
},
new List <Path>()
{
new Path("OutputFile.out"),
}));
}
/// <summary>
/// Link
/// </summary>
public BuildOperation CreateLinkOperation(
LinkArguments arguments)
{
// Select the correct executable for linking libraries or executables
Path executablePath;
switch (arguments.TargetType)
{
case LinkTarget.StaticLibrary:
executablePath = _libraryExecutable;
break;
case LinkTarget.DynamicLibrary:
case LinkTarget.Executable:
case LinkTarget.WindowsApplication:
executablePath = _linkerExecutable;
break;
default:
throw new InvalidOperationException("Unknown LinkTarget.");
}
// Build the set of input/output files along with the arguments
var inputFiles = new List <Path>();
inputFiles.AddRange(arguments.LibraryFiles);
inputFiles.AddRange(arguments.ObjectFiles);
var outputFiles = new List <Path>()
{
arguments.TargetRootDirectory + arguments.TargetFile,
};
var commandarguments = ArgumentBuilder.BuildLinkerArguments(arguments);
var buildOperation = new BuildOperation(
arguments.TargetFile.ToString(),
arguments.TargetRootDirectory,
executablePath,
CombineArguments(commandarguments),
inputFiles,
outputFiles);
return(buildOperation);
}
public void LinkWindowsApplication_Simple()
{
var uut = new Compiler(
new Path("C:/bin/mock.cl.exe"),
new Path("C:/bin/mock.link.exe"),
new Path("C:/bin/mock.lib.exe"),
new Path("C:/bin/mock.rc.exe"));
var arguments = new LinkArguments();
arguments.TargetType = LinkTarget.WindowsApplication;
arguments.TargetArchitecture = "x64";
arguments.TargetFile = new Path("Something.exe");
arguments.TargetRootDirectory = new Path("C:/target/");
arguments.ObjectFiles = new List <Path>()
{
new Path("File.mock.obj"),
};
arguments.LibraryFiles = new List <Path>()
{
new Path("Library.mock.a"),
};
var result = uut.CreateLinkOperation(arguments);
// Verify result
var expected = new BuildOperation(
"./Something.exe",
new Path("C:/target/"),
new Path("C:/bin/mock.link.exe"),
"/nologo /subsystem:windows /machine:X64 /out:\"./Something.exe\" ./Library.mock.a ./File.mock.obj",
new List <Path>()
{
new Path("Library.mock.a"),
new Path("File.mock.obj"),
},
new List <Path>()
{
new Path("C:/target/Something.exe"),
});
Assert.Equal(expected, result);
}
public void ZeroObjectFiles()
{
var arguments = new LinkArguments()
{
TargetType = LinkTarget.StaticLibrary,
TargetArchitecture = "x64",
TargetFile = new Path("Library.mock.lib"),
ObjectFiles = new List <Path>(),
};
var actualArguments = ArgumentBuilder.BuildLinkerArguments(arguments);
var expectedArguments = new List <string>()
{
"/nologo",
"/machine:X64",
"/out:\"./Library.mock.lib\"",
};
Assert.Equal(expectedArguments, actualArguments);
}
internal static string GetSelfFunction(SageContext context, params string[] arguments)
{
var linkArguments = new LinkArguments(arguments, false, "encode", "absolute");
var currentUrl = linkArguments.Switches["absolute"]
? context.Url.RawUrl
: context.Url.RawPathAndQuery;
var paramQuery = new QueryString(parameterSeparators);
if (currentUrl.Contains("?"))
{
var questionIndex = currentUrl.IndexOf("?", StringComparison.Ordinal);
paramQuery.Parse(currentUrl.Substring(questionIndex + 1));
currentUrl = currentUrl.Substring(0, questionIndex);
}
paramQuery.Merge(linkArguments.QueryString);
var result = string.Concat(currentUrl, paramQuery.ToString("?"), string.IsNullOrEmpty(linkArguments.HashString)
? string.Empty
: string.Concat("#", linkArguments.HashString));
if (linkArguments.Switches["encode"] && !string.IsNullOrEmpty(result))
result = HttpUtility.UrlEncode(result);
return result;
}
internal static string GetProjectLinkFunction(SageContext context, params string[] arguments)
{
var linkArguments = new LinkArguments(arguments, false, "encode", "absolute", "pretty");
var result = linkArguments.Switches["absolute"]
? context.Url.ApplicationRoot
: context.Request.ApplicationPath;
if (linkArguments.Switches["encode"] && !string.IsNullOrEmpty(result))
result = HttpUtility.UrlEncode(result);
return result + (result.EndsWith("/") ? string.Empty : "/");
}
internal static string GetLinkFunction(SageContext context, params string[] arguments)
{
var linkArguments = new LinkArguments(arguments, true, "encode", "absolute");
var qualify = linkArguments.Switches["absolute"];
var result = context.Url.GetUrl(linkArguments.LinkName, linkArguments.QueryString, linkArguments.HashString, qualify);
if (linkArguments.Switches["encode"] && !string.IsNullOrEmpty(result))
result = HttpUtility.UrlEncode(result);
return result;
}
public static IList <string> BuildLinkerArguments(
LinkArguments arguments)
{
// Verify the input
if (string.IsNullOrEmpty(arguments.TargetFile.GetFileName()))
{
throw new InvalidOperationException("Target file cannot be empty.");
}
var commandArguments = new List <string>();
// Disable the logo
AddFlag(commandArguments, ArgumentFlag_NoLogo);
// Disable the default libraries, we will set this up
// AddFlag(commandArguments, Linker_ArgumentFlag_NoDefaultLibraries);
// Enable verbose output
// AddFlag(commandArguments, Linker_ArgumentFlag_Verbose);
// Generate source debug information
if (arguments.GenerateSourceDebugInfo)
{
AddParameter(commandArguments, "debug", "full");
}
// Calculate object output file
switch (arguments.TargetType)
{
case LinkTarget.StaticLibrary:
{
break;
}
case LinkTarget.DynamicLibrary:
{
// TODO: May want to specify the exact value
// set the default lib to mutlithreaded
// AddParameter(commandArguments, "defaultlib", "libcmt");
AddParameter(commandArguments, "subsystem", "console");
// Create a dynamic library
AddFlag(commandArguments, Linker_ArgumentFlag_DLL);
// Set the output implementation library
AddParameterWithQuotes(
commandArguments,
Linker_ArgumentParameter_ImplementationLibrary,
arguments.ImplementationFile.ToString());
break;
}
case LinkTarget.Executable:
{
// TODO: May want to specify the exact value
// set the default lib to multithreaded
// AddParameter(commandArguments, "defaultlib", "libcmt");
AddParameter(commandArguments, "subsystem", "console");
break;
}
case LinkTarget.WindowsApplication:
{
// TODO: May want to specify the exact value
// set the default lib to multithreaded
// AddParameter(commandArguments, "defaultlib", "libcmt");
AddParameter(commandArguments, "subsystem", "windows");
break;
}
default:
{
throw new InvalidOperationException("Unknown LinkTarget.");
}
}
// Add the machine target
if (arguments.TargetArchitecture == "x64")
{
AddParameter(commandArguments, Linker_ArgumentParameter_Machine, Linker_ArgumentValue_X64);
}
else if (arguments.TargetArchitecture == "x86")
{
AddParameter(commandArguments, Linker_ArgumentParameter_Machine, Linker_ArgumentValue_X86);
}
else
{
throw new InvalidOperationException("Unknown target architecture.");
}
// Set the library paths
foreach (var directory in arguments.LibraryPaths)
{
AddParameterWithQuotes(commandArguments, Linker_ArgumentParameter_LibraryPath, directory.ToString());
}
// Add the target as an output
AddParameterWithQuotes(commandArguments, Linker_ArgumentParameter_Output, arguments.TargetFile.ToString());
// Add the library files
foreach (var file in arguments.LibraryFiles)
{
// Add the library files as input
commandArguments.Add(file.ToString());
}
// Add the external libraries as default libraries so they are resolved last
foreach (var file in arguments.ExternalLibraryFiles)
{
// Add the external library files as input
// TODO: Explicitly ignore these files from the input for now
AddParameter(commandArguments, Linker_ArgumentParameter_DefaultLibrary, file.ToString());
}
// Add the object files
foreach (var file in arguments.ObjectFiles)
{
// Add the object files as input
commandArguments.Add(file.ToString());
}
return(commandArguments);
}
