mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-18 17:02:10 -10:00
* Token.cs: Commented Transform and LiteralSubExpression and added
FunctionName token.
* ConditionParser.cs: Removed redundant casts, rewrote
ParseFactorExpression () and added parsing of '!'.
* ConditionTokenizer.cs: Always skip whitespaces when getting next
token (no IgnoreWhiteSpace property). Don't create a token from '->'.
Moved ReadChar () in front of all ifs.
svn path=/trunk/mcs/; revision=71350
381 lines
9.8 KiB
C#
381 lines
9.8 KiB
C#
//
|
|
// Engine.cs: Main engine of XBuild.
|
|
//
|
|
// Author:
|
|
// Marek Sieradzki ([email protected])
|
|
//
|
|
// (C) 2005 Marek Sieradzki
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
#if NET_2_0
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using Microsoft.Build.Framework;
|
|
using Mono.XBuild.Utilities;
|
|
|
|
namespace Microsoft.Build.BuildEngine {
|
|
public class Engine {
|
|
|
|
string binPath;
|
|
bool buildEnabled;
|
|
TaskDatabase defaultTasks;
|
|
bool defaultTasksRegistered;
|
|
const string defaultTasksProjectName = "Microsoft.Common.tasks";
|
|
EventSource eventSource;
|
|
bool buildStarted;
|
|
BuildPropertyGroup globalProperties;
|
|
//IDictionary importedProjects;
|
|
List <ILogger> loggers;
|
|
//bool onlyLogCriticalEvents;
|
|
Dictionary <string, Project> projects;
|
|
|
|
static Engine globalEngine;
|
|
static Version version;
|
|
|
|
static Engine ()
|
|
{
|
|
version = new Version ("0.1");
|
|
}
|
|
|
|
public Engine ()
|
|
: this (null)
|
|
{
|
|
}
|
|
|
|
// engine should be invoked with path where binary files are
|
|
// to find microsoft.build.tasks
|
|
public Engine (string binPath)
|
|
{
|
|
this.binPath = binPath;
|
|
this.buildEnabled = true;
|
|
this.projects = new Dictionary <string, Project> ();
|
|
this.eventSource = new EventSource ();
|
|
this.loggers = new List <ILogger> ();
|
|
this.buildStarted = false;
|
|
this.globalProperties = new BuildPropertyGroup ();
|
|
|
|
RegisterDefaultTasks ();
|
|
}
|
|
|
|
[MonoTODO]
|
|
public bool BuildProject (Project project)
|
|
{
|
|
return project.Build ();
|
|
}
|
|
|
|
[MonoTODO]
|
|
public bool BuildProject (Project project, string targetName)
|
|
{
|
|
return BuildProject (project, new string[] { targetName}, null, BuildSettings.None);
|
|
}
|
|
|
|
[MonoTODO]
|
|
public bool BuildProject (Project project, string[] targetNames)
|
|
{
|
|
return BuildProject (project, targetNames, null, BuildSettings.None);
|
|
}
|
|
|
|
[MonoTODO]
|
|
public bool BuildProject (Project project,
|
|
string[] targetNames,
|
|
IDictionary targetOutputs)
|
|
{
|
|
return BuildProject (project, targetNames, targetOutputs, BuildSettings.None);
|
|
}
|
|
|
|
[MonoTODO ("use buildFlags")]
|
|
public bool BuildProject (Project project,
|
|
string[] targetNames,
|
|
IDictionary targetOutputs,
|
|
BuildSettings buildFlags)
|
|
{
|
|
bool result;
|
|
|
|
StartBuild ();
|
|
|
|
LogProjectStarted (project, targetNames);
|
|
|
|
result = project.Build (targetNames, targetOutputs);
|
|
|
|
LogProjectFinished (project, result);
|
|
|
|
return result;
|
|
}
|
|
|
|
[MonoTODO]
|
|
public bool BuildProjectFile (string projectFile)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
[MonoTODO]
|
|
public bool BuildProjectFile (string projectFile,
|
|
string targetName)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
[MonoTODO]
|
|
public bool BuildProjectFile (string projectFile,
|
|
string[] targetNames)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
[MonoTODO]
|
|
public bool BuildProjectFile (string projectFile,
|
|
string[] targetNames,
|
|
BuildPropertyGroup globalProperties)
|
|
{
|
|
return BuildProjectFile (projectFile, targetNames, globalProperties, null, BuildSettings.None);
|
|
}
|
|
|
|
[MonoTODO]
|
|
public bool BuildProjectFile (string projectFile,
|
|
string[] targetNames,
|
|
BuildPropertyGroup globalProperties,
|
|
IDictionary targetOutputs)
|
|
{
|
|
return BuildProjectFile (projectFile, targetNames, globalProperties, targetOutputs, BuildSettings.None);
|
|
}
|
|
|
|
[MonoTODO ("use buildFlags")]
|
|
public bool BuildProjectFile (string projectFile,
|
|
string[] targetNames,
|
|
BuildPropertyGroup globalProperties,
|
|
IDictionary targetOutputs,
|
|
BuildSettings buildFlags)
|
|
{
|
|
bool result;
|
|
Project project;
|
|
|
|
StartBuild ();
|
|
|
|
if (projects.ContainsKey (projectFile)) {
|
|
project = (Project) projects [projectFile];
|
|
LogProjectStarted (project, targetNames);
|
|
result = project.Build (targetNames, targetOutputs);
|
|
} else {
|
|
project = CreateNewProject ();
|
|
project.Load (projectFile);
|
|
LogProjectStarted (project, targetNames);
|
|
result = project.Build (targetNames, targetOutputs);
|
|
}
|
|
|
|
LogProjectFinished (project, result);
|
|
|
|
return result;
|
|
}
|
|
|
|
void CheckBinPath ()
|
|
{
|
|
if (BinPath == null) {
|
|
throw new InvalidOperationException ("Before a project can be instantiated, " +
|
|
"Engine.BinPath must be set to the location on disk where MSBuild " +
|
|
"is installed. This is used to evaluate $(MSBuildBinPath).");
|
|
}
|
|
}
|
|
|
|
public Project CreateNewProject ()
|
|
{
|
|
if (defaultTasksRegistered)
|
|
CheckBinPath ();
|
|
return new Project (this);
|
|
}
|
|
|
|
public Project GetLoadedProject (string projectFullFileName)
|
|
{
|
|
if (projectFullFileName == null)
|
|
throw new ArgumentNullException ("projectFullFileName");
|
|
|
|
// FIXME: test it
|
|
return projects [projectFullFileName];
|
|
}
|
|
|
|
internal void RemoveLoadedProject (Project p)
|
|
{
|
|
if (p.FullFileName != String.Empty)
|
|
projects.Remove (p.FullFileName);
|
|
}
|
|
|
|
internal void AddLoadedProject (Project p)
|
|
{
|
|
if (p.FullFileName != String.Empty)
|
|
projects.Add (p.FullFileName, p);
|
|
}
|
|
|
|
public void UnloadProject (Project project)
|
|
{
|
|
if (project == null)
|
|
throw new ArgumentNullException ("project");
|
|
|
|
if (project.ParentEngine != this)
|
|
throw new InvalidOperationException ("The \"Project\" object specified does not belong to the correct \"Engine\" object.");
|
|
|
|
project.CheckUnloaded ();
|
|
|
|
if (project.FullFileName != String.Empty)
|
|
projects.Remove (project.FullFileName);
|
|
|
|
project.Unload ();
|
|
}
|
|
|
|
public void UnloadAllProjects ()
|
|
{
|
|
foreach (KeyValuePair <string, Project> e in projects)
|
|
UnloadProject (e.Value);
|
|
}
|
|
|
|
[MonoTODO]
|
|
public void RegisterLogger (ILogger logger)
|
|
{
|
|
if (logger == null)
|
|
throw new ArgumentNullException ("logger");
|
|
|
|
logger.Initialize (eventSource);
|
|
loggers.Add (logger);
|
|
}
|
|
|
|
[MonoTODO]
|
|
public void UnregisterAllLoggers ()
|
|
{
|
|
// FIXME: check if build succeeded
|
|
// FIXME: it shouldn't be here
|
|
LogBuildFinished (true);
|
|
foreach (ILogger i in loggers) {
|
|
i.Shutdown ();
|
|
}
|
|
loggers.Clear ();
|
|
}
|
|
|
|
internal void StartBuild ()
|
|
{
|
|
if (!buildStarted) {
|
|
LogBuildStarted ();
|
|
buildStarted = true;
|
|
}
|
|
}
|
|
|
|
void LogProjectStarted (Project project, string [] targetNames)
|
|
{
|
|
ProjectStartedEventArgs psea;
|
|
if (targetNames.Length == 0) {
|
|
if (project.DefaultTargets != String.Empty)
|
|
psea = new ProjectStartedEventArgs ("Project started.", null, project.FullFileName,
|
|
project.DefaultTargets, null, null);
|
|
else
|
|
psea = new ProjectStartedEventArgs ("Project started.", null, project.FullFileName, "default", null, null);
|
|
} else
|
|
psea = new ProjectStartedEventArgs ("Project started.", null, project.FullFileName, String.Join (";",
|
|
targetNames), null, null);
|
|
eventSource.FireProjectStarted (this, psea);
|
|
}
|
|
|
|
void LogProjectFinished (Project project, bool succeeded)
|
|
{
|
|
ProjectFinishedEventArgs pfea;
|
|
pfea = new ProjectFinishedEventArgs ("Project started.", null, project.FullFileName, succeeded);
|
|
eventSource.FireProjectFinished (this, pfea);
|
|
}
|
|
|
|
void LogBuildStarted ()
|
|
{
|
|
BuildStartedEventArgs bsea;
|
|
bsea = new BuildStartedEventArgs ("Build started.", null);
|
|
eventSource.FireBuildStarted (this, bsea);
|
|
}
|
|
|
|
void LogBuildFinished (bool succeeded)
|
|
{
|
|
BuildFinishedEventArgs bfea;
|
|
bfea = new BuildFinishedEventArgs ("Build finished.", null, succeeded);
|
|
eventSource.FireBuildFinished (this, bfea);
|
|
}
|
|
|
|
void RegisterDefaultTasks ()
|
|
{
|
|
this.defaultTasksRegistered = false;
|
|
|
|
Project defaultTasksProject = CreateNewProject ();
|
|
|
|
if (binPath != null) {
|
|
if (File.Exists (Path.Combine (binPath, defaultTasksProjectName))) {
|
|
defaultTasksProject.Load (Path.Combine (binPath, defaultTasksProjectName));
|
|
defaultTasks = defaultTasksProject.TaskDatabase;
|
|
} else
|
|
defaultTasks = new TaskDatabase ();
|
|
} else
|
|
defaultTasks = new TaskDatabase ();
|
|
|
|
this.defaultTasksRegistered = true;
|
|
}
|
|
|
|
public string BinPath {
|
|
get { return binPath; }
|
|
set { binPath = value; }
|
|
}
|
|
|
|
public bool BuildEnabled {
|
|
get { return buildEnabled; }
|
|
set { buildEnabled = value; }
|
|
}
|
|
|
|
public static Version Version {
|
|
get { return version; }
|
|
}
|
|
|
|
public static Engine GlobalEngine {
|
|
get {
|
|
if (globalEngine == null)
|
|
globalEngine = new Engine ();
|
|
return globalEngine;
|
|
}
|
|
}
|
|
|
|
public BuildPropertyGroup GlobalProperties {
|
|
get { return globalProperties; }
|
|
set { globalProperties = value; }
|
|
}
|
|
|
|
public bool OnlyLogCriticalEvents {
|
|
get { return eventSource.OnlyLogCriticalEvents; }
|
|
set { eventSource.OnlyLogCriticalEvents = value; }
|
|
}
|
|
|
|
internal EventSource EventSource {
|
|
get { return eventSource; }
|
|
}
|
|
|
|
internal bool DefaultTasksRegistered {
|
|
get { return defaultTasksRegistered; }
|
|
}
|
|
|
|
internal TaskDatabase DefaultTasks {
|
|
get { return defaultTasks; }
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|