private void AddBuildToolProperties(BuildTool buildTool, Project proj)
{
ProjectPropertyGroupElement group = proj.Xml.AddPropertyGroup();
if (!string.IsNullOrEmpty(buildTool.BuildToolWrapper))
{
group.AddProperty(ToolWrapperTag, buildTool.BuildToolWrapper);
}
group.AddProperty(CCompilerTag, buildTool.ToolPath + buildTool.CCompiler.Exec);
group.AddProperty(CppCompilerTag, buildTool.ToolPath + buildTool.CppCompiler.Exec);
group.AddProperty(AsmCompilerTag, buildTool.ToolPath + buildTool.AsmCompiler.Exec);
group.AddProperty(LinkerTag, buildTool.ToolPath + buildTool.Linker.Exec);
group.AddProperty(ArchiverTag, buildTool.ToolPath + buildTool.Archiver.Exec);
group.AddProperty(FromElfTag, buildTool.ToolPath + buildTool.FromELF.Exec);
foreach (MiscBuildTool tool in buildTool.MiscTools)
{
group.AddProperty(tool.Name, tool.ToolPath + tool.BuildTool.Exec);
}
}
private void AddBuildTools(BuildTool buildTool, Project proj)
{
foreach (MiscBuildTool tool in buildTool.MiscTools)
{
AddBuildScript(tool.Name, tool.BuildTool.Conditional, ToEnvVar(ToolWrapperTag), tool.BuildToolOptions, proj, ToEnvVar(tool.Name + "_FLAGS"));
}
AddBuildScript(CCompilerTargetTag , buildTool.CCompiler.Conditional , ToEnvVar(ToolWrapperTag), buildTool.BuildOptions.CFlags , proj, ToEnvVar(CommonToolFlagTag), ToEnvVar(CFlagTag) , ToEnvVar(CCppCommonFlagTag));
AddBuildScript(CppCompilerTargetTag, buildTool.CppCompiler.Conditional, ToEnvVar(ToolWrapperTag), buildTool.BuildOptions.CppFlags , proj, ToEnvVar(CommonToolFlagTag), ToEnvVar(CppFlagTag), ToEnvVar(CCppCommonFlagTag));
AddBuildScript(AsmCompilerTargetTag, buildTool.AsmCompiler.Conditional, ToEnvVar(ToolWrapperTag), buildTool.BuildOptions.AsmFlags, proj, ToEnvVar(CommonToolFlagTag), ToEnvVar(AsmFlagTag));
AddBuildScript(LibTargetTag , buildTool.Archiver.Conditional , ToEnvVar(ToolWrapperTag), buildTool.BuildOptions.ArchiverFlags, proj, ToEnvVar(CommonToolFlagTag), ToEnvVar(ArchiverFlagTag));
AddBuildScript(ExeTargetTag , buildTool.Linker.Conditional , ToEnvVar(ToolWrapperTag), buildTool.BuildOptions.LinkerFlags , proj, ToEnvVar(CommonToolFlagTag), ToEnvVar(LinkerFlagTag));
}
internal void LoadTargetFile(BuildTool tool, string fileName)
{
Project proj;
string fullpath = ExpandEnvVars(fileName, "");
try
{
proj = LoadProject(fullpath);
foreach (ProjectImportElement import in proj.Xml.Imports)
{
if (string.IsNullOrEmpty(import.Condition))
{
LoadTargetFile(tool, ExpandVars(import.Project, Path.GetDirectoryName(fileName)));
}
}
Regex expISA = new Regex(@"'\$\(INSTRUCTION_SET\)'=='", RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
foreach (ProjectPropertyGroupElement pg in proj.Xml.PropertyGroups)
{
if (expISA.IsMatch(pg.Condition))
{
ISA isa = LoadISASettings(pg);
if (isa != null)
{
tool.SupportedISAs.Add(isa);
}
continue;
}
tool.BuildOptions = LoadToolChainOptions(pg);
foreach (ProjectPropertyElement bp in pg.Properties)
{
string cond = CombineConditionals(pg.Condition, bp.Condition);
switch (bp.Name)
{
case "BuildToolName":
tool.Name = bp.Value;
break;
case "Documentation":
tool.Documentation = bp.Value;
break;
case "BuildToolGuid":
tool.Guid = bp.Value;
break;
case ObjExtFlag:
tool.ObjExt = bp.Value;
break;
case LibExtFlag:
tool.LibExt = bp.Value;
break;
case ExeExtFlag:
tool.BinExt = bp.Value;
break;
case CCompilerTag:
tool.CCompiler.Exec = RemoveWrapper(bp.Value);
break;
case CppCompilerTag:
tool.CppCompiler.Exec = RemoveWrapper(bp.Value);
break;
case AsmCompilerTag:
tool.AsmCompiler.Exec = RemoveWrapper(bp.Value);
break;
case ArchiverTag:
tool.Archiver.Exec = RemoveWrapper(bp.Value);
break;
case LinkerTag:
tool.Linker.Exec = RemoveWrapper(bp.Value);
break;
case FromElfTag:
tool.FromELF.Exec = RemoveWrapper(bp.Value);
break;
case ToolWrapperTag:
case AdsWrapperTag:
case AdiWrapperTag:
case ArcWrapperTag:
tool.BuildToolWrapper = RemoveWrapper(bp.Value);
break;
case PKUI_CpuNamesTag:
{
List<string> pts = (List<string>)this.DeserializeXml(bp.Value, typeof(List<string>));
tool.SupportedCpuNames.AddRange(pts);
}
break;
case "ProcessorTypes":
case CpuNamesTag:
{
foreach (string sType in bp.Value.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
tool.SupportedCpuNames.Add(sType);
}
}
break;
case PKUI_ISAsTag:
{
List<ISA> isas = (List<ISA>)this.DeserializeXml(bp.Value, typeof(List<ISA>));
tool.SupportedISAs.AddRange(isas);
}
break;
case ISAsTag:
{
//legacy
if (bp.Value.Contains(";"))
{
foreach (string sISA in bp.Value.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
ISA isa = new ISA();
isa.Name = sISA;
isa.Guid = System.Guid.NewGuid().ToString("B");
tool.SupportedISAs.Add(isa);
}
}
}
break;
default:
{
MFProperty prop = new MFProperty();
prop.Name = bp.Name;
prop.Value = bp.Value;
prop.Condition = cond;
tool.Properties.Add(prop);
}
break;
}
}
}
foreach (ProjectItemGroupElement big in proj.Xml.ItemGroups)
{
foreach (ProjectItemElement bi in big.Items)
{
string cond = CombineConditionals(big.Condition, bi.Condition);
MFProperty prop = new MFProperty();
prop.Name = bi.ItemType;
prop.Value = bi.Include;
prop.Condition = cond;
tool.Items.Add(prop);
}
}
foreach (ProjectTargetElement targ in proj.Xml.Targets)
{
switch (targ.Name)
{
case AdiAsmTargetTag:
case ArmAsmTargetTag:
case ArcAsmTargetTag:
case AsmCompilerTargetTag:
tool.AsmCompiler.Conditional = targ.Condition;
tool.AsmCompiler.Description = AsmCompilerTag;
LoadTargetTasks(targ, tool.BuildOptions.EnvironmentVariables, tool.AsmCompiler, tool.BuildOptions.AsmFlags, tool.BuildOptions.CommonFlags);
break;
case AdiCCompilerTargetTag:
case ArmCCompilerTargetTag:
case ArcCCompilerTargetTag:
case CCompilerTargetTag:
tool.CCompiler.Conditional = targ.Condition;
tool.CCompiler.Description = CCompilerTag;
LoadTargetTasks(targ, tool.BuildOptions.EnvironmentVariables, tool.CCompiler, tool.BuildOptions.CFlags, tool.BuildOptions.C_CppFlags, tool.BuildOptions.CommonFlags);
break;
case AdiCppCompilerTargetTag:
case ArmCppCompilerTargetTag:
case ArcCppCompilerTargetTag:
case CppCompilerTargetTag:
tool.CppCompiler.Conditional = targ.Condition;
tool.CppCompiler.Description = CppCompilerTag;
LoadTargetTasks(targ, tool.BuildOptions.EnvironmentVariables, tool.CppCompiler, tool.BuildOptions.CppFlags, tool.BuildOptions.C_CppFlags, tool.BuildOptions.CommonFlags);
break;
case AdiLibTargetTag:
case ArmLibTargetTag:
case ArcLibTargetTag:
case LibTargetTag:
tool.Archiver.Conditional = targ.Condition;
tool.Archiver.Description = ArchiverTag;
LoadTargetTasks(targ, tool.BuildOptions.EnvironmentVariables, tool.Archiver, tool.BuildOptions.ArchiverFlags);
break;
case AdiExeTargetTag:
case ArmExeTargetTag:
case ArcExeTargetTag:
case ExeTargetTag:
tool.Linker.Conditional = targ.Condition;
tool.Linker.Description = LinkerTag;
LoadTargetTasks(targ, tool.BuildOptions.EnvironmentVariables, tool.Linker, tool.BuildOptions.LinkerFlags);
break;
default:
MiscBuildTool misc = new MiscBuildTool();
misc.BuildTool.Conditional = targ.Condition;
misc.BuildTool.Exec = targ.Name;
misc.BuildTool.Description = targ.Name;
misc.Name = targ.Name;
LoadTargetTasks(targ, misc.EnvironmentVariables, misc.BuildTool, misc.BuildToolOptions);
tool.MiscTools.Add(misc);
break;
}
}
BuildToolDefine[] tools = new BuildToolDefine[]
{
tool.Archiver,
tool.AsmCompiler,
tool.CCompiler,
tool.CppCompiler,
tool.Linker,
tool.FromELF,
};
//first time to determine path
foreach (BuildToolDefine td in tools)
{
ExtractToolPath(tool, td.Exec);
}
//second time to remove path from exec command
foreach (BuildToolDefine td in tools)
{
td.Exec = ExtractToolPath(tool, td.Exec);
}
tool.ProjectPath = ConvertPathToEnv(fileName);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("Error: loading target file: " + fullpath + "\r\n", e.Message);
}
}
internal BuildTool LoadBuildToolFromTargetFile(string fileName)
{
BuildTool tool = new BuildTool();
string fullpath = ExpandEnvVars(fileName, "");
if (!File.Exists(fullpath)) return null;
//TODO: Load processor/proctype specific data into processor/procType build options
tool.Name = Path.GetFileNameWithoutExtension(fullpath).ToUpper().Replace("MICROSOFT.SPOT.SYSTEM.", "");
string settingsFile = Path.Combine(Path.GetDirectoryName(fullpath), Path.GetFileNameWithoutExtension(fullpath) + ".settings");
if (File.Exists(settingsFile))
{
LoadTargetFile(tool, settingsFile);
}
LoadTargetFile(tool, fullpath);
m_helper.DefaultInventory.BuildTools.Add(tool);
return tool;
}
// -- //
internal void SaveTargetFile(BuildTool tool)
{
string fullpath = ExpandEnvVars(tool.ProjectPath, "");
try
{
Project proj = GenerateBuildToolTargetFile(tool);
proj.Save(fullpath);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("Error: saving target file: " + fullpath + "\r\n", e.Message);
}
}
private string ExtractToolPath(BuildTool tool, string exeLocation)
{
if (string.IsNullOrEmpty(exeLocation)) return "";
exeLocation = exeLocation.Trim();
exeLocation = exeLocation.TrimStart(' ', '"', '\\');
exeLocation = exeLocation.TrimEnd(' ', '"');
exeLocation = exeLocation.Replace(ToEnvVar(AdiWrapperTag), "");
exeLocation = exeLocation.Replace(ToEnvVar(ArcWrapperTag), "");
exeLocation = exeLocation.Replace(ToEnvVar(AdsWrapperTag), "");
if (string.IsNullOrEmpty(tool.ToolPath))
{
string tmp = exeLocation.Replace("\"", "");
tool.ToolPath = Path.GetDirectoryName(tmp) + "\\";
exeLocation = exeLocation.Remove(0, tool.ToolPath.Length).TrimStart(' ', '\\', '"');
}
else if (exeLocation.ToLower().StartsWith(tool.ToolPath.ToLower()))
{
exeLocation = exeLocation.Remove(0, tool.ToolPath.Length).TrimStart(' ', '\\', '"');
}
else
{
do
{
tool.ToolPath = Path.GetDirectoryName(tool.ToolPath);
}
while (tool.ToolPath.Length > 0 && exeLocation.ToLower().StartsWith(tool.ToolPath.ToLower()));
if (tool.ToolPath.Length > 0)
{
exeLocation = exeLocation.Remove(0, tool.ToolPath.Length);
}
}
return exeLocation.TrimStart('\\', ' ', '"');
}
private Project GenerateBuildToolTargetFile(BuildTool buildTool)
{
Project proj = new Project();
proj.Xml.DefaultTargets = "Build";
ProjectPropertyGroupElement mainGrp = proj.Xml.AddPropertyGroup();
mainGrp.AddProperty("BuildToolName", buildTool.Name);
mainGrp.AddProperty("BuildToolGuid", buildTool.Guid);
mainGrp.AddProperty("Documentation", buildTool.Documentation);
if (buildTool.SupportedCpuNames.Count > 0)
{
mainGrp.AddProperty(CpuNamesTag, string.Join( ";", buildTool.SupportedCpuNames.ToArray() ) );
}
if (buildTool.SupportedISAs.Count > 0)
{
foreach (ISA isa in buildTool.SupportedISAs)
{
ProjectPropertyGroupElement bgISA = proj.Xml.AddPropertyGroup();
bgISA.Condition = "'$(INSTRUCTION_SET)'=='" + isa.Name + "'";
bgISA.AddProperty(ISAsTag, isa.Name);
AddBuildToolFlags(isa.BuildToolOptions, proj, bgISA);
}
}
AddBuildToolProperties(buildTool, proj);
if (buildTool.Properties.Count > 0)
{
ProjectPropertyGroupElement bpg = proj.Xml.AddPropertyGroup();
foreach (MFProperty prop in buildTool.Properties)
{
ProjectPropertyElement bp = bpg.AddProperty(prop.Name, prop.Value);
bp.Condition = prop.Condition;
}
}
AddEnvVarCollection(buildTool.BuildOptions.EnvironmentVariables, proj);
AddBuildToolFlags(buildTool.BuildOptions, proj, null);
AddMiscToolFlags(buildTool.MiscTools, proj);
if (buildTool.Items.Count > 0)
{
ProjectItemGroupElement big = proj.Xml.AddItemGroup();
foreach (MFProperty prop in buildTool.Items)
{
ProjectItemElement bi = big.AddItem(prop.Name, prop.Value);
bi.Condition = prop.Condition;
}
}
AddBuildTools(buildTool, proj);
return proj;
}
public void CopyTo(BuildTool dest)
{
CopyHelper.CopyTo(this, dest);
}
private void addBuildToolToolStripMenuItem_Click(object sender, EventArgs e)
{
TreeNode parent = treeViewInventory.Nodes[0].Nodes["BuildTools"];
BuildTool newTool = new BuildTool();
newTool.Guid = Guid.NewGuid().ToString("B").ToUpper();
TreeNode newNode = AddTreeElement(parent, "<New Build Tool>", newTool, true, DefaultInventory.BuildTools, c_defaultInventoryKey);
DefaultInventory.BuildTools.Add(newTool);
treeViewInventory.SelectedNode = newNode;
newNode.BeginEdit();
}
