public object ReadFile(FilePath fileName, Type expectedType, IProgressMonitor monitor)
{
string ext = Path.GetExtension(fileName).ToLower();
if (ext != ".mdw")
{
throw new ArgumentException();
}
object readObject = null;
ProjectExtensionUtil.BeginLoadOperation();
try {
readObject = ReadWorkspaceItemFile(fileName, monitor);
} finally {
ProjectExtensionUtil.EndLoadOperation();
}
IWorkspaceFileObject fo = readObject as IWorkspaceFileObject;
if (fo != null)
{
fo.ConvertToFormat(MD1ProjectService.FileFormat, false);
}
return(readObject);
}
public object ReadFile(FilePath fileName, Type expectedType, IProgressMonitor monitor)
{
object readObject = null;
ProjectExtensionUtil.BeginLoadOperation();
try {
string ext = Path.GetExtension(fileName).ToLower();
if (ext == ".mdp")
{
object project = ReadProjectFile(fileName, monitor);
if (project is DotNetProject)
{
((DotNetProject)project).SetItemHandler(new MD1DotNetProjectHandler((DotNetProject)project));
}
readObject = project;
}
else if (ext == ".mds")
{
readObject = ReadCombineFile(fileName, monitor);
}
else if (ext == ".mdw")
{
readObject = ReadWorkspaceItemFile(fileName, monitor);
}
else
{
XmlTextReader reader = new XmlTextReader(new StreamReader(fileName));
try {
monitor.BeginTask(string.Format(GettextCatalog.GetString("Loading solution item: {0}"), fileName), 1);
reader.MoveToContent();
XmlDataSerializer ser = new XmlDataSerializer(MD1ProjectService.DataContext);
ser.SerializationContext.BaseFile = fileName;
ser.SerializationContext.ProgressMonitor = monitor;
SolutionEntityItem entry = (SolutionEntityItem)ser.Deserialize(reader, typeof(SolutionEntityItem));
entry.FileName = fileName;
MD1ProjectService.InitializeHandler(entry);
readObject = entry;
}
catch (Exception ex) {
monitor.ReportError(string.Format(GettextCatalog.GetString("Could not load solution item: {0}"), fileName), ex);
throw;
}
finally {
monitor.EndTask();
reader.Close();
}
}
} finally {
ProjectExtensionUtil.EndLoadOperation();
}
IWorkspaceFileObject fo = readObject as IWorkspaceFileObject;
if (fo != null)
{
fo.ConvertToFormat(MD1ProjectService.FileFormat, false);
}
return(readObject);
}
public List <FilePath> GetItemFiles(object obj)
{
List <FilePath> col = new List <FilePath> ();
DotNetProject mp = obj as DotNetProject;
if (mp != null)
{
MonoSolutionItemHandler handler = ProjectExtensionUtil.GetItemHandler(mp) as MonoSolutionItemHandler;
if (handler != null && File.Exists(handler.SourcesFile))
{
col.Add(mp.FileName);
col.Add(handler.SourcesFile);
}
}
return(col);
}
internal override void SetItemHandler(ISolutionItemHandler handler)
{
if (ProjectExtensionUtil.GetItemHandler(this) == null)
{
// Initial assignment of the item handler
base.SetItemHandler(handler);
return;
}
IResourceHandler rh = ResourceHandler;
base.SetItemHandler(handler);
resourceHandler = null;
// A change in the file format may imply a change in the resource naming policy.
// Make sure that the resource Id don't change.
MigrateResourceIds(rh, ResourceHandler);
}
public UnitTest CreateUnitTest(IWorkspaceObject entry)
{
if (entry is DotNetProject)
{
DotNetProject project = (DotNetProject)entry;
MonoSolutionItemHandler handler = ProjectExtensionUtil.GetItemHandler(project) as MonoSolutionItemHandler;
if (handler != null)
{
if (handler.UnitTest != null)
{
return((UnitTest)handler.UnitTest);
}
string testFileBase = handler.GetTestFileBase();
UnitTest testSuite = new MonoTestSuite(project, project.Name, testFileBase);
handler.UnitTest = testSuite;
return(testSuite);
}
}
return(null);
}
protected override BuildResult OnBuild(IProgressMonitor monitor, ConfigurationSelector configuration)
{
if (!Project.InternalCheckNeedsBuild(configuration))
{
monitor.Log.WriteLine(GettextCatalog.GetString("Skipping project since output files are up to date"));
return(new BuildResult());
}
DotNetProject project = Project;
if (!project.TargetRuntime.IsInstalled(project.TargetFramework))
{
BuildResult res = new BuildResult();
res.AddError(GettextCatalog.GetString("Framework '{0}' not installed.", project.TargetFramework.Name));
return(res);
}
bool hasBuildableFiles = false;
foreach (ProjectFile pf in project.Files)
{
if (pf.BuildAction == BuildAction.Compile || pf.BuildAction == BuildAction.EmbeddedResource)
{
hasBuildableFiles = true;
break;
}
}
if (!hasBuildableFiles)
{
return(new BuildResult());
}
if (project.LanguageBinding == null)
{
BuildResult langres = new BuildResult();
string msg = GettextCatalog.GetString("Unknown language '{0}'. You may need to install an additional add-in to support this language.", project.LanguageName);
langres.AddError(msg);
monitor.ReportError(msg, null);
return(langres);
}
BuildResult refres = null;
HashSet <ProjectItem> itemsToExclude = new HashSet <ProjectItem> ();
foreach (ProjectReference pr in project.References)
{
if (pr.ReferenceType == ReferenceType.Project)
{
// Ignore non-dotnet projects
Project p = project.ParentSolution != null?project.ParentSolution.FindProjectByName(pr.Reference) : null;
if (p != null && !(p is DotNetProject))
{
continue;
}
if (p == null || pr.GetReferencedFileNames(configuration).Length == 0)
{
if (refres == null)
{
refres = new BuildResult();
}
string msg = GettextCatalog.GetString("Referenced project '{0}' not found in the solution.", pr.Reference);
monitor.ReportWarning(msg);
refres.AddWarning(msg);
}
}
if (!pr.IsValid)
{
if (refres == null)
{
refres = new BuildResult();
}
string msg;
if (!pr.IsExactVersion && pr.SpecificVersion)
{
msg = GettextCatalog.GetString("Reference '{0}' not found on system. Using '{1}' instead.", pr.StoredReference, pr.Reference);
monitor.ReportWarning(msg);
refres.AddWarning(msg);
}
else
{
bool errorsFound = false;
foreach (string asm in pr.GetReferencedFileNames(configuration))
{
if (!File.Exists(asm))
{
msg = GettextCatalog.GetString("Assembly '{0}' not found. Make sure that the assembly exists in disk. If the reference is required to build the project you may get compilation errors.", Path.GetFileName(asm));
refres.AddWarning(msg);
monitor.ReportWarning(msg);
errorsFound = true;
itemsToExclude.Add(pr);
}
}
msg = null;
if (!errorsFound)
{
msg = GettextCatalog.GetString("The reference '{0}' is not valid for the target framework of the project.", pr.StoredReference, pr.Reference);
monitor.ReportWarning(msg);
refres.AddWarning(msg);
itemsToExclude.Add(pr);
}
}
}
}
DotNetProjectConfiguration conf = (DotNetProjectConfiguration)project.GetConfiguration(configuration);
// Create a copy of the data needed to compile the project.
// This data can be modified by extensions.
// Also filter out items whose condition evaluates to false
BuildData buildData = new BuildData();
ProjectParserContext ctx = new ProjectParserContext(project, conf);
buildData.Items = new ProjectItemCollection();
foreach (ProjectItem item in project.Items)
{
if (!itemsToExclude.Contains(item) && (string.IsNullOrEmpty(item.Condition) || ConditionParser.ParseAndEvaluate(item.Condition, ctx)))
{
buildData.Items.Add(item);
}
}
buildData.Configuration = (DotNetProjectConfiguration)conf.Clone();
buildData.Configuration.SetParentItem(project);
buildData.ConfigurationSelector = configuration;
return(ProjectExtensionUtil.Compile(monitor, project, buildData, delegate {
ProjectItemCollection items = buildData.Items;
BuildResult res = BuildResources(buildData.Configuration, ref items, monitor);
if (res != null)
{
return res;
}
res = project.LanguageBinding.Compile(items, buildData.Configuration, buildData.ConfigurationSelector, monitor);
if (refres != null)
{
refres.Append(res);
return refres;
}
else
{
return res;
}
}));
}
/// <summary>
/// Initializes a new instance of the <see cref="MonoDevelop.Projects.SolutionItem"/> class.
/// </summary>
public SolutionItem()
{
ProjectExtensionUtil.LoadControl(this);
}
public static bool IsMonoProject(object obj)
{
DotNetProject p = obj as DotNetProject;
return(p != null && (ProjectExtensionUtil.GetItemHandler(p) is MonoSolutionItemHandler));
}
public object ReadFile(FilePath fileName, bool hasParentSolution, IProgressMonitor monitor)
{
FilePath basePath = fileName.ParentDirectory;
MonoMakefile mkfile = new MonoMakefile(fileName);
string aname = mkfile.GetVariable("LIBRARY");
if (aname == null)
{
aname = mkfile.GetVariable("PROGRAM");
}
try {
ProjectExtensionUtil.BeginLoadOperation();
if (aname != null)
{
// It is a project
monitor.BeginTask("Loading '" + fileName + "'", 0);
DotNetAssemblyProject project = new DotNetAssemblyProject("C#");
MonoSolutionItemHandler handler = new MonoSolutionItemHandler(project);
ProjectExtensionUtil.InstallHandler(handler, project);
project.Name = Path.GetFileName(basePath);
handler.Read(mkfile);
monitor.EndTask();
return(project);
}
else
{
string subdirs;
StringBuilder subdirsBuilder = new StringBuilder();
subdirsBuilder.Append(mkfile.GetVariable("common_dirs"));
if (subdirsBuilder.Length != 0)
{
subdirsBuilder.Append("\t");
subdirsBuilder.Append(mkfile.GetVariable("net_2_0_dirs"));
}
if (subdirsBuilder.Length == 0)
{
subdirsBuilder.Append(mkfile.GetVariable("SUBDIRS"));
}
subdirs = subdirsBuilder.ToString();
if (subdirs != null && (subdirs = subdirs.Trim(' ', '\t')) != "")
{
object retObject;
SolutionFolder folder;
if (!hasParentSolution)
{
Solution sol = new Solution();
sol.ConvertToFormat(Services.ProjectService.FileFormats.GetFileFormat("MonoMakefile"), false);
sol.FileName = fileName;
folder = sol.RootFolder;
retObject = sol;
foreach (string conf in MonoMakefileFormat.Configurations)
{
SolutionConfiguration sc = new SolutionConfiguration(conf);
sol.Configurations.Add(sc);
}
}
else
{
folder = new SolutionFolder();
folder.Name = Path.GetFileName(Path.GetDirectoryName(fileName));
retObject = folder;
}
subdirs = subdirs.Replace('\t', ' ');
string[] dirs = subdirs.Split(' ');
monitor.BeginTask("Loading '" + fileName + "'", dirs.Length);
Hashtable added = new Hashtable();
foreach (string dir in dirs)
{
if (added.Contains(dir))
{
continue;
}
added.Add(dir, dir);
monitor.Step(1);
if (dir == null)
{
continue;
}
string tdir = dir.Trim();
if (tdir == "")
{
continue;
}
string mfile = Path.Combine(Path.Combine(basePath, tdir), "Makefile");
if (File.Exists(mfile) && CanReadFile(mfile, typeof(SolutionItem)))
{
SolutionItem it = (SolutionItem)ReadFile(mfile, true, monitor);
folder.Items.Add(it);
}
}
monitor.EndTask();
return(retObject);
}
}
} finally {
ProjectExtensionUtil.EndLoadOperation();
}
return(null);
}
public ProjectParameters()
{
ProjectExtensionUtil.LoadControl(this);
}
