protected IProject ProjectCreator()
{
var dialog = new NameDialog();
if (dialog.ShowDialog() == DialogResult.OK)
{
var name = dialog.EnteredText;
var solutionDir = FSolution.Location.GetLocalDir();
var projectPath = solutionDir.ConcatPath(name).ConcatPath(name + ".csproj");
var location = new Uri(projectPath);
var project = new CSProject(Path.GetFileName(location.LocalPath), location);
if (File.Exists(project.Location.LocalPath))
{
project.Load();
}
else
{
project.Save();
}
return(project);
}
else
{
return(null);
}
}
private bool RecompileIfNeeded(CSProject project)
{
if (!IsAssemblyUpToDate(project))
{
FLogger.Log(LogType.Message, "Assembly of {0} is not up to date. Need to recompile ...", project.Name);
var isLoaded = project.IsLoaded;
if (!isLoaded)
{
project.Load();
}
project.ProjectCompiledSuccessfully -= project_ProjectCompiled;
project.Compile();
project.ProjectCompiledSuccessfully += project_ProjectCompiled;
if (!isLoaded)
{
project.Unload();
}
if (project.CompilerResults.Errors.HasErrors)
{
FLogger.Log(LogType.Error, GetCompileErrorsLog(project, project.CompilerResults));
return(false);
}
}
return(true);
}
void AddOrUpdateAssembly(CSProject cs)
{
if (cs.AssemblyLocation != null)
{
foreach (var a in AppDomain.CurrentDomain.GetAssemblies())
{
try
{
if ((!a.IsDynamic) && a.Location == cs.AssemblyLocation)
{
if (FCSProjects.ContainsKey(cs))
{
UpdateAssembly(cs, a);
}
else
{
FCSProjects.Add(cs, a);
}
}
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e);
}
}
}
}
public override string Generate(ProjectBase Project, bool WithBeutyConfigurationName)
{
CSProject project = (CSProject)Project;
CSProject.Profile profile = (CSProject.Profile)project.Profiles[0];
XmlElement projectElement = CreateProjectElement();
{
XmlElement propertyGroup = CreateElement("PropertyGroup", projectElement);
{
SetElementValue("AssemblyName", profile.AssemblyName, propertyGroup);
SetElementValue("OutputPath", profile.OutputPath, propertyGroup);
SetElementValue("OutputType", GetOutputType(profile), propertyGroup);
SetElementValue("DefineConstants", GetFlattenStringList(profile.PreprocessorDefinitions), propertyGroup);
SetElementValue("TargetFrameworkVersion", profile.FrameworkVersion.ToString().Replace('_', '.'), propertyGroup);
}
XmlElement target = CreateElement("Target", projectElement);
{
target.SetAttribute("Name", "Build");
XmlElement makeDir = CreateElement("MakeDir", target);
{
makeDir.SetAttribute("Directories", "$(OutputPath)");
makeDir.SetAttribute("Condition", "!Exists('$(OutputPath)')");
makeDir = CreateElement("Csc", target);
makeDir.SetAttribute("Sources", "@(Compile)");
makeDir.SetAttribute("OutputAssembly", "$(OutputPath)$(AssemblyName)");
target = CreateElement("Target", projectElement);
{
target.SetAttribute("Name", "Clean");
makeDir = CreateElement("Delete", target);
makeDir.SetAttribute("Files", "$(OutputPath)$(AssemblyName)");
target = CreateElement("Target", projectElement);
{
target.SetAttribute("Name", "Rebuild");
target.SetAttribute("DependsOnTargets", "Clean;Build");
}
}
}
XmlElement import = CreateElement("Import", projectElement);
import.SetAttribute("Project", "$(MSBuildToolsPath)/Microsoft.CSharp.targets");
XmlElement referencesItemGroup = CreateElement("ItemGroup", projectElement);
AddStringListToEllementAsAttribute(referencesItemGroup, "Reference", "Include", project.ReferenceBinaryFiles);
XmlElement compilesItemGroup = CreateElement("ItemGroup", projectElement);
AddStringListToEllementAsAttribute(compilesItemGroup, "Compile", "Include", project.CompileFiles);
}
}
return(projectElement.OwnerDocument.OuterXml);
}
private bool IsAssemblyUpToDate(CSProject project)
{
if (project.AssemblyLocation == null)
{
return(false);
}
var now = DateTime.Now;
var projectTime = new [] { File.GetLastWriteTime(project.LocalPath) }
.Concat(project.Documents.Select(d => File.GetLastWriteTime(d.LocalPath)))
.Max();
var assemblyTime = File.GetLastWriteTime(project.AssemblyLocation);
// This can happen in case the computer time is wrong or
// in a different time zone than the project was created in.
if (now < projectTime)
{
projectTime = now - TimeSpan.FromSeconds(10.0);
}
if (File.Exists(project.AssemblyLocation) && (projectTime <= assemblyTime))
{
// We also need to check if the version info of the referenced assemblies
// is the same as the one referenced by the project file.
// We only check the PluginInterfaces assembly here to save performance.
var assembly = Assembly.ReflectionOnlyLoadFrom(project.AssemblyLocation);
var piAssembly = assembly.GetReferencedAssemblies().Where(assemblyName => assemblyName.Name == typeof(IPluginBase).Assembly.GetName().Name).FirstOrDefault();
if (piAssembly != null && piAssembly.Version != FPluginInterfacesVersion)
{
return(false);
}
switch (project.BuildConfiguration)
{
case BuildConfiguration.Release:
return(!IsAssemblyDebugBuild(assembly));
case BuildConfiguration.Debug:
return(IsAssemblyDebugBuild(assembly));
default:
return(true);
}
}
return(false);
}
private CSProject CreateProject(string filename)
{
var project = FSolution.Projects[filename] as CSProject;
if (project == null)
{
var binDir = Path.GetDirectoryName(filename).ConcatPath("bin").ConcatPath("Dynamic");
DeleteArtefacts(binDir);
project = new CSProject(filename);
FSolution.Projects.Add(project);
project.ProjectCompiledSuccessfully += project_ProjectCompiled;
project.CompileCompleted += project_CompileCompleted;
}
return(project);
}
void UpdateAssembly(CSProject cs, Assembly a)
{
FCSProjects[cs] = a;
foreach (var kv in FTypeToProject)
{
if (kv.Value == cs)
{
var t = a.GetType(kv.Key, false, true);
if (t != null)
{
FMappings[kv.Key] = t;
TypeUpdated?.Invoke(this, kv.Key);
}
}
}
}
private bool BuildWrapperLibrary(List <string> WrapperFiles)
{
const string ProjectName = "Wrapper";
string projectDir = EnvironmentHelper.IntermediateDirectory + ProjectName + EnvironmentHelper.PathSeparator;
if (!Directory.Exists(projectDir))
{
Directory.CreateDirectory(projectDir);
}
CSProject csproj = new CSProject();
CSProject.Profile profile = (CSProject.Profile)csproj.CreateProfile();
profile.FrameworkVersion = CSProject.Profile.FrameworkVersions.v4_5;
profile.AssemblyName = ProjectName;
profile.OutputPath = projectDir + "Build" + EnvironmentHelper.PathSeparator;
profile.IntermediatePath = projectDir;
profile.OutputType = ProjectBase.ProfileBase.OutputTypes.DynamicLinkLibrary;
DateTime startTime = DateTime.Now;
ConsoleHelper.WriteInfo("Building wrapper starts at " + startTime.ToString());
if (WrapperFiles.Count == 0)
{
ConsoleHelper.WriteInfo("No building rules found, aborting process");
return(false);
}
foreach (string file in WrapperFiles)
{
csproj.AddCompileFile(file);
}
if (compiler.Build(profile))
{
return(true);
}
ConsoleHelper.WriteInfo("Building wrapper takes " + (DateTime.Now - startTime).ToHHMMSS());
return(false);
}
protected static CSDocument FindDefiningDocument(CSProject project, INodeInfo nodeInfo)
{
foreach (var doc in project.Documents)
{
var csDoc = doc as CSDocument;
if (csDoc == null)
{
continue;
}
if (FindDefiningLine(csDoc, nodeInfo) >= 0)
{
return(csDoc);
}
}
return(null);
}
protected IProject ProjectCreator()
{
var dialog = new NameDialog();
if (dialog.ShowDialog() == DialogResult.OK)
{
var name = dialog.EnteredText;
var solutionDir = Path.GetDirectoryName(FSolution.LocalPath);
var projectPath = solutionDir.ConcatPath(name).ConcatPath(name + ".csproj");
var project = new CSProject(projectPath);
if (!File.Exists(project.LocalPath))
{
project.Save();
}
return(project);
}
else
{
return(null);
}
}
protected override bool CloneNode(INodeInfo nodeInfo, string path, string name, string category, string version, out string newFilename)
{
string className = string.Format("{0}{1}{2}Node", version, category, name);
className = Regex.Replace(className, @"[^a-zA-Z0-9]+", "_");
var regexp = new Regex(@"^[0-9]+");
if (regexp.IsMatch(className))
{
className = string.Format("C{0}", className);
}
// Find a suitable project name
var newProjectName = string.Format("{0}{1}{2}", version, category, name);;
var newProjectPath = path.ConcatPath(newProjectName).ConcatPath(newProjectName + ".csproj");
int i = 1;
string tmpNewProjectName = newProjectName;
string tmpClassName = className;
while (File.Exists(newProjectPath))
{
newProjectName = tmpNewProjectName + i;
className = tmpClassName + i++;
newProjectPath = path.ConcatPath(newProjectName).ConcatPath(newProjectName + ".csproj");
}
var filename = nodeInfo.Filename;
var project = CreateProject(filename);
project.SaveTo(newProjectPath);
using (var newProject = new CSProject(newProjectPath))
{
foreach (var doc in newProject.Documents)
{
var csDoc = doc as CSDocument;
if (csDoc != null)
{
// Rename the CSDocument
if (ContainsNodeInfo(csDoc, nodeInfo))
{
var newDocName = string.Format("{0}.cs", Path.GetFileNameWithoutExtension(className));
csDoc.Name = newDocName;
csDoc.Rename(newDocName);
break;
}
}
}
foreach (var doc in newProject.Documents)
{
// Now scan the document for possible plugin infos.
// If we find one, update its properties and rename the class.
var csDoc = doc as CSDocument;
if (csDoc != null)
{
var parserResults = csDoc.Parse(true);
var compilationUnit = parserResults.CompilationUnit;
// Write new values to plugin info and remove all other plugin infos.
var pluginInfoTransformer = new PluginClassTransformer(nodeInfo, name, category, version, className);
compilationUnit.AcceptVisitor(pluginInfoTransformer, null);
var outputVisitor = new CSharpOutputVisitor();
var specials = parserResults.Specials;
using (SpecialNodesInserter.Install(specials, outputVisitor))
{
outputVisitor.VisitCompilationUnit(compilationUnit, null);
}
csDoc.TextContent = outputVisitor.Text;
}
}
// Save the project.
newProject.Save();
newFilename = newProject.LocalPath;
return(true);
}
}
public bool Build()
{
string projectDir = EnvironmentHelper.IntermediateDirectory + ProjectName + EnvironmentHelper.PathSeparator;
if (!Directory.Exists(projectDir))
{
Directory.CreateDirectory(projectDir);
}
CSProject csproj = new CSProject();
CSProject.Profile profile = (CSProject.Profile)csproj.CreateProfile();
profile.FrameworkVersion = CSProject.Profile.FrameworkVersions.v4_5;
profile.AssemblyName = ProjectName;
profile.OutputPath = projectDir + "Build" + EnvironmentHelper.PathSeparator;
profile.IntermediatePath = projectDir;
profile.OutputType = ProjectBase.ProfileBase.OutputTypes.DynamicLinkLibrary;
csproj.AddReferenceBinaryFile(Assembly.GetExecutingAssembly().Location);
string[] files = FileSystemUtilites.GetAllFiles(processDirectory, "*" + BuildRules.BuildRuleFilePostfix);
DateTime startTime = DateTime.Now;
ConsoleHelper.WriteInfo("Building rules starts at " + startTime.ToString());
ConsoleHelper.WriteInfo("Found rules :");
if (files.Length == 0)
{
ConsoleHelper.WriteInfo("No building rules found, aborting process");
return(false);
}
foreach (string rules in files)
{
csproj.AddCompileFile(rules);
ConsoleHelper.WriteInfo("\t" + Path.GetFileName(rules));
}
Compiler compiler = new Compiler();
compiler.ErrorRaised += OnError;
if (compiler.Build(profile))
{
Assembly rulesLibrary = Assembly.LoadFile(profile.OutputPath + ProjectName + EnvironmentHelper.DynamicLibraryExtentions);
List <string> buildRulesFiles = new List <string>();
List <BuildRules> buildRules = new List <BuildRules>();
foreach (string buildRuleName in files)
{
string fileName = Path.GetFileNameWithoutExtension(buildRuleName);
string typeName = fileName.Replace(".", "");
Type type = rulesLibrary.GetType(BuildRules.NamespacePrefix + typeName);
if (type == null)
{
ConsoleHelper.WriteWarning("In " + fileName + ", type " + typeName + " doesn't exists, building related module will be ignore");
continue;
}
buildRulesFiles.Add(buildRuleName);
BuildRules buildRule = (BuildRules)Activator.CreateInstance(type);
buildRule.Path = FileSystemUtilites.PathSeperatorCorrection(Path.GetDirectoryName(buildRuleName)) + EnvironmentHelper.PathSeparator;
Type[] types = buildRule.GetType().GetNestedTypes();
buildRule.Rules = new BuildRules.RuleBase[types.Length];
for (int i = 0; i < types.Length; ++i)
{
buildRule.Rules[i] = (BuildRules.RuleBase)Activator.CreateInstance(types[i]);
}
buildRules.Add(buildRule);
}
RulesFiles = buildRulesFiles.ToArray();
Rules = buildRules.ToArray();
return(true);
}
ConsoleHelper.WriteInfo("Building rules takes " + (DateTime.Now - startTime).ToHHMMSS());
return(false);
}
