OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

update Prebuild with WhiteCore version

httptests
UbitUmarov 2017-08-30 22:24:07 +01:00
parent d4a3aa5e08
commit 41e8b9f91f
54 changed files with 8241 additions and 8139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
Prebuild/ChangeLog
View File

@ -1,3 +1,17 @@
2015, June Fly-Man- <fly.man.opensim@gmail.com>
* V2.0.7 (WhiteCore Build)
* Added the VS2012/VS2013 targets so .Net 4.5 can be used for WhiteCore
* Cleaned up the SharpDevelop2 code part
2015, April rowan Deppeler <greythane@gmail.com>
* V2.0.6w (WhiteCore build
* No changes to the code as it appears development has now stalled at 1.10
- Incorporated (Rev's, I think) patches from Aurora to provide for passing the framework
and additional conditionals in the Prebuild.xml spec
- Re-built using Net 4.0 framework to provide for use on unmodified Windows 8 systems (No Net 3.5)
- Included Solution and project files to assist building if required
2008-12-09T02:15 D. Moonfire <d.moonfire@mfgames.com> 2008-12-09T02:15 D. Moonfire <d.moonfire@mfgames.com>
* src/Core/Kernel.cs * src/Core/Kernel.cs
- Added a /ppi target to get the results of processing but before - Added a /ppi target to get the results of processing but before

12
Prebuild/prebuild.xml
View File

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="utf-8" ?> <?xml version="1.0" encoding="utf-8" ?>
<Prebuild xmlns="http://dnpb.sourceforge.net/schemas/prebuild-1.10.xsd" version="1.10"> <Prebuild xmlns="http://dnpb.sourceforge.net/schemas/prebuild-1.10.xsd" version="1.10">
<Solution name="Prebuild" version="2.0.6"> <Solution name="Prebuild" version="2.0.7">
<Configuration name="Debug"> <Configuration name="Debug">
<Options> <Options>
<CompilerDefines>DEBUG;TRACE</CompilerDefines> <CompilerDefines>DEBUG;TRACE</CompilerDefines>
@ -21,7 +21,6 @@
</Configuration> </Configuration>
<Files> <Files>
<File>prebuild.xml</File> <File>prebuild.xml</File>
<File>prebuild</File>
</Files> </Files>
<Project name="Prebuild" <Project name="Prebuild"
path="src" path="src"
@ -31,8 +30,8 @@
type="Exe" type="Exe"
rootNamespace="Prebuild" rootNamespace="Prebuild"
startupObject="Prebuild.Prebuild" startupObject="Prebuild.Prebuild"
version="2.0.6" version="2.0.7"
frameworkVersion="v3_5" frameworkVersion="v4_0"
> >
<Author>Matthew Holmes (matthew@wildfiregames.com)</Author> <Author>Matthew Holmes (matthew@wildfiregames.com)</Author>
<Author>Dan Moorehead (dan05a@gmail.com)</Author> <Author>Dan Moorehead (dan05a@gmail.com)</Author>
@ -40,6 +39,7 @@
<Author>Rob Loach (http://robloach.net)</Author> <Author>Rob Loach (http://robloach.net)</Author>
<Author>C.J. Adams-Collier (cjac@colliertech.org)</Author> <Author>C.J. Adams-Collier (cjac@colliertech.org)</Author>
<Author>John Hurliman (john.hurliman@intel.com)</Author> <Author>John Hurliman (john.hurliman@intel.com)</Author>
<Author>WhiteCore build (2015) Rowan Deppeler (greythan@gmail.com)</Author>
<Description>The Prebuild project generator</Description> <Description>The Prebuild project generator</Description>
<Configuration name="Debug"> <Configuration name="Debug">
<Options> <Options>
@ -68,7 +68,9 @@
<Match pattern="App.ico" buildAction="EmbeddedResource"/> <Match pattern="App.ico" buildAction="EmbeddedResource"/>
<Match path="data" pattern="prebuild-1.10.xsd" buildAction="EmbeddedResource"/> <Match path="data" pattern="prebuild-1.10.xsd" buildAction="EmbeddedResource"/>
<Match path="data" pattern="autotools.xml" buildAction="EmbeddedResource"/> <Match path="data" pattern="autotools.xml" buildAction="EmbeddedResource"/>
<Match pattern="*.cs" recurse="true"/> <Match pattern="*.cs" recurse="true">
<Exclude name="obj" pattern="obj"/>
</Match>
</Files> </Files>
</Project> </Project>
</Solution> </Solution>

66
Prebuild/src/Core/Attributes/DataNodeAttribute.cs
View File

@ -28,45 +28,45 @@ using System.Collections.Specialized;
namespace Prebuild.Core.Attributes namespace Prebuild.Core.Attributes
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple=true)] [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple=true)]
public sealed class DataNodeAttribute : Attribute public sealed class DataNodeAttribute : Attribute
{ {
#region Fields #region Fields
private string m_Name = "unknown"; private string m_Name = "unknown";
#endregion #endregion
#region Constructors #region Constructors
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="DataNodeAttribute"/> class. /// Initializes a new instance of the <see cref="DataNodeAttribute"/> class.
/// </summary> /// </summary>
/// <param name="name">The name.</param> /// <param name="name">The name.</param>
public DataNodeAttribute(string name) public DataNodeAttribute(string name)
{ {
m_Name = name; m_Name = name;
} }
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// Gets the name. /// Gets the name.
/// </summary> /// </summary>
/// <value>The name.</value> /// <value>The name.</value>
public string Name public string Name
{ {
get get
{ {
return m_Name; return m_Name;
} }
} }
#endregion #endregion
} }
} }

66
Prebuild/src/Core/Attributes/OptionNodeAttribute.cs
View File

@ -27,45 +27,45 @@ using System;
namespace Prebuild.Core.Attributes namespace Prebuild.Core.Attributes
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[AttributeUsage(AttributeTargets.Field)] [AttributeUsage(AttributeTargets.Field)]
public sealed class OptionNodeAttribute : Attribute public sealed class OptionNodeAttribute : Attribute
{ {
#region Fields #region Fields
private string m_NodeName; private string m_NodeName;
#endregion #endregion
#region Constructors #region Constructors
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="OptionNodeAttribute"/> class. /// Initializes a new instance of the <see cref="OptionNodeAttribute"/> class.
/// </summary> /// </summary>
/// <param name="nodeName">Name of the node.</param> /// <param name="nodeName">Name of the node.</param>
public OptionNodeAttribute(string nodeName) public OptionNodeAttribute(string nodeName)
{ {
m_NodeName = nodeName; m_NodeName = nodeName;
} }
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// Gets the name of the node. /// Gets the name of the node.
/// </summary> /// </summary>
/// <value>The name of the node.</value> /// <value>The name of the node.</value>
public string NodeName public string NodeName
{ {
get get
{ {
return m_NodeName; return m_NodeName;
} }
} }
#endregion #endregion
} }
} }

66
Prebuild/src/Core/Attributes/TargetAttribute.cs
View File

@ -27,45 +27,45 @@ using System;
namespace Prebuild.Core.Attributes namespace Prebuild.Core.Attributes
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct)] [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct)]
public sealed class TargetAttribute : Attribute public sealed class TargetAttribute : Attribute
{ {
#region Fields #region Fields
private string m_Name; private string m_Name;
#endregion #endregion
#region Constructors #region Constructors
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="TargetAttribute"/> class. /// Initializes a new instance of the <see cref="TargetAttribute"/> class.
/// </summary> /// </summary>
/// <param name="name">The name.</param> /// <param name="name">The name.</param>
public TargetAttribute(string name) public TargetAttribute(string name)
{ {
m_Name = name; m_Name = name;
} }
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// Gets the name. /// Gets the name.
/// </summary> /// </summary>
/// <value>The name.</value> /// <value>The name.</value>
public string Name public string Name
{ {
get get
{ {
return m_Name; return m_Name;
} }
} }
#endregion #endregion
} }
} }

94
Prebuild/src/Core/FatalException.cs
View File

@ -28,58 +28,58 @@ using System.Runtime.Serialization;
namespace Prebuild.Core namespace Prebuild.Core
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[Serializable()] [Serializable()]
public class FatalException : Exception public class FatalException : Exception
{ {
#region Constructors #region Constructors
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="FatalException"/> class. /// Initializes a new instance of the <see cref="FatalException"/> class.
/// </summary> /// </summary>
public FatalException() public FatalException()
{ {
} }
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="FatalException"/> class. /// Initializes a new instance of the <see cref="FatalException"/> class.
/// </summary> /// </summary>
/// <param name="format">The format.</param> /// <param name="format">The format.</param>
/// <param name="args">The args.</param> /// <param name="args">The args.</param>
public FatalException(string format, params object[] args) public FatalException(string format, params object[] args)
: base(String.Format(format, args)) : base(String.Format(format, args))
{ {
} }
/// <summary> /// <summary>
/// Exception with specified string /// Exception with specified string
/// </summary> /// </summary>
/// <param name="message">Exception message</param> /// <param name="message">Exception message</param>
public FatalException(string message): base(message) public FatalException(string message): base(message)
{ {
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
/// <param name="message"></param> /// <param name="message"></param>
/// <param name="exception"></param> /// <param name="exception"></param>
public FatalException(string message, Exception exception) : base(message, exception) public FatalException(string message, Exception exception) : base(message, exception)
{ {
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
/// <param name="info"></param> /// <param name="info"></param>
/// <param name="context"></param> /// <param name="context"></param>
protected FatalException(SerializationInfo info, StreamingContext context) : base( info, context ) protected FatalException(SerializationInfo info, StreamingContext context) : base( info, context )
{ {
} }
#endregion #endregion
} }
} }

32
Prebuild/src/Core/Interfaces/IDataNode.cs
View File

@ -28,20 +28,20 @@ using System.Xml;
namespace Prebuild.Core.Interfaces namespace Prebuild.Core.Interfaces
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public interface IDataNode public interface IDataNode
{ {
/// <summary> /// <summary>
/// Gets or sets the parent. /// Gets or sets the parent.
/// </summary> /// </summary>
/// <value>The parent.</value> /// <value>The parent.</value>
IDataNode Parent { get; set; } IDataNode Parent { get; set; }
/// <summary> /// <summary>
/// Parses the specified node. /// Parses the specified node.
/// </summary> /// </summary>
/// <param name="node">The node.</param> /// <param name="node">The node.</param>
void Parse(XmlNode node); void Parse(XmlNode node);
} }
} }

42
Prebuild/src/Core/Interfaces/ITarget.cs
View File

@ -27,25 +27,25 @@ using System;
namespace Prebuild.Core.Interfaces namespace Prebuild.Core.Interfaces
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public interface ITarget public interface ITarget
{ {
/// <summary> /// <summary>
/// Writes the specified kern. /// Writes the specified kern.
/// </summary> /// </summary>
/// <param name="kern">The kern.</param> /// <param name="kern">The kern.</param>
void Write(Kernel kern); void Write(Kernel kern);
/// <summary> /// <summary>
/// Cleans the specified kern. /// Cleans the specified kern.
/// </summary> /// </summary>
/// <param name="kern">The kern.</param> /// <param name="kern">The kern.</param>
void Clean(Kernel kern); void Clean(Kernel kern);
/// <summary> /// <summary>
/// Gets the name. /// Gets the name.
/// </summary> /// </summary>
/// <value>The name.</value> /// <value>The name.</value>
string Name { get; } string Name { get; }
} }
} }

1265
Prebuild/src/Core/Kernel.cs
View File

File diff suppressed because it is too large Load Diff

84
Prebuild/src/Core/Nodes/AuthorNode.cs
View File

@ -32,56 +32,56 @@ using Prebuild.Core.Utilities;
namespace Prebuild.Core.Nodes namespace Prebuild.Core.Nodes
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[DataNode("Author")] [DataNode("Author")]
public class AuthorNode : DataNode public class AuthorNode : DataNode
{ {
#region Fields #region Fields
private string m_Signature; private string m_Signature;
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// Gets the signature. /// Gets the signature.
/// </summary> /// </summary>
/// <value>The signature.</value> /// <value>The signature.</value>
public string Signature public string Signature
{ {
get get
{ {
return m_Signature; return m_Signature;
} }
} }
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// Parses the specified node. /// Parses the specified node.
/// </summary> /// </summary>
/// <param name="node">The node.</param> /// <param name="node">The node.</param>
public override void Parse(XmlNode node) public override void Parse(XmlNode node)
{ {
if( node == null ) if( node == null )
{ {
throw new ArgumentNullException("node"); throw new ArgumentNullException("node");
} }
m_Signature = Helper.InterpolateForEnvironmentVariables(node.InnerText); m_Signature = Helper.InterpolateForEnvironmentVariables(node.InnerText);
if(m_Signature == null) if(m_Signature == null)
{ {
m_Signature = ""; m_Signature = "";
} }
m_Signature = m_Signature.Trim(); m_Signature = m_Signature.Trim();
} }
#endregion #endregion
} }
} }

56
Prebuild/src/Core/Nodes/CleanupNode.cs
View File

@ -35,40 +35,40 @@ namespace Prebuild.Core.Nodes
[DataNode("Cleanup")] [DataNode("Cleanup")]
public class CleanupNode : DataNode public class CleanupNode : DataNode
{ {
#region Fields #region Fields
private List<CleanFilesNode> m_CleanFiles = new List<CleanFilesNode>(); private List<CleanFilesNode> m_CleanFiles = new List<CleanFilesNode>();
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// Gets the signature. /// Gets the signature.
/// </summary> /// </summary>
/// <value>The signature.</value> /// <value>The signature.</value>
public List<CleanFilesNode> CleanFiles public List<CleanFilesNode> CleanFiles
{ {
get get
{ {
return m_CleanFiles; return m_CleanFiles;
} }
} }
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// Parses the specified node. /// Parses the specified node.
/// </summary> /// </summary>
/// <param name="node">The node.</param> /// <param name="node">The node.</param>
public override void Parse(XmlNode node) public override void Parse(XmlNode node)
{ {
if( node == null ) if( node == null )
{ {
throw new ArgumentNullException("node"); throw new ArgumentNullException("node");
} }
foreach (XmlNode child in node.ChildNodes) foreach (XmlNode child in node.ChildNodes)
{ {
@ -78,8 +78,8 @@ namespace Prebuild.Core.Nodes
m_CleanFiles.Add((CleanFilesNode)dataNode); m_CleanFiles.Add((CleanFilesNode)dataNode);
} }
} }
} }
#endregion #endregion
} }
} }

312
Prebuild/src/Core/Nodes/ConfigurationNode.cs
View File

@ -32,185 +32,185 @@ using Prebuild.Core.Utilities;
namespace Prebuild.Core.Nodes namespace Prebuild.Core.Nodes
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[DataNode("Configuration")] [DataNode("Configuration")]
public class ConfigurationNode : DataNode, ICloneable, IComparable public class ConfigurationNode : DataNode, ICloneable, IComparable
{ {
#region Fields #region Fields
private string m_Name = "unknown"; private string m_Name = "unknown";
private string m_Platform = "AnyCPU"; private string m_Platform = "AnyCPU";
private OptionsNode m_Options; private OptionsNode m_Options;
#endregion #endregion
#region Constructors #region Constructors
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="ConfigurationNode"/> class. /// Initializes a new instance of the <see cref="ConfigurationNode"/> class.
/// </summary> /// </summary>
public ConfigurationNode() public ConfigurationNode()
{ {
m_Options = new OptionsNode(); m_Options = new OptionsNode();
} }
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// Gets or sets the parent. /// Gets or sets the parent.
/// </summary> /// </summary>
/// <value>The parent.</value> /// <value>The parent.</value>
public override IDataNode Parent public override IDataNode Parent
{ {
get get
{ {
return base.Parent; return base.Parent;
} }
set set
{ {
base.Parent = value; base.Parent = value;
if(base.Parent is SolutionNode) if(base.Parent is SolutionNode)
{ {
SolutionNode node = (SolutionNode)base.Parent; SolutionNode node = (SolutionNode)base.Parent;
if(node != null && node.Options != null) if(node != null && node.Options != null)
{ {
node.Options.CopyTo(m_Options); node.Options.CopyTo(m_Options);
} }
} }
} }
} }
/// <summary> /// <summary>
/// Identifies the platform for this specific configuration. /// Identifies the platform for this specific configuration.
/// </summary> /// </summary>
public string Platform public string Platform
{ {
get get
{ {
return m_Platform; return m_Platform;
} }
set set
{ {
switch ((value + "").ToLower()) switch ((value + "").ToLower())
{ {
case "x86": case "x86":
case "x64": case "x64":
m_Platform = value; m_Platform = value;
break; break;
case "itanium": case "itanium":
m_Platform = "Itanium"; m_Platform = "Itanium";
break; break;
default: default:
m_Platform = "AnyCPU"; m_Platform = "AnyCPU";
break; break;
} }
} }
} }
/// <summary> /// <summary>
/// Gets the name. /// Gets the name.
/// </summary> /// </summary>
/// <value>The name.</value> /// <value>The name.</value>
public string Name public string Name
{ {
get get
{ {
return m_Name; return m_Name;
} }
} }
/// <summary> /// <summary>
/// Gets the name and platform for the configuration. /// Gets the name and platform for the configuration.
/// </summary> /// </summary>
/// <value>The name and platform.</value> /// <value>The name and platform.</value>
public string NameAndPlatform public string NameAndPlatform
{ {
get get
{ {
string platform = m_Platform; string platform = m_Platform;
if (platform == "AnyCPU") if (platform == "AnyCPU")
platform = "Any CPU"; platform = "Any CPU";
return String.Format("{0}|{1}", m_Name, platform); return String.Format("{0}|{1}", m_Name, platform);
} }
} }
/// <summary> /// <summary>
/// Gets or sets the options. /// Gets or sets the options.
/// </summary> /// </summary>
/// <value>The options.</value> /// <value>The options.</value>
public OptionsNode Options public OptionsNode Options
{ {
get get
{ {
return m_Options; return m_Options;
} }
set set
{ {
m_Options = value; m_Options = value;
} }
} }
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// Parses the specified node. /// Parses the specified node.
/// </summary> /// </summary>
/// <param name="node">The node.</param> /// <param name="node">The node.</param>
public override void Parse(XmlNode node) public override void Parse(XmlNode node)
{ {
m_Name = Helper.AttributeValue(node, "name", m_Name); m_Name = Helper.AttributeValue(node, "name", m_Name);
Platform = Helper.AttributeValue(node, "platform", m_Platform); Platform = Helper.AttributeValue(node, "platform", m_Platform);
if (node == null) if (node == null)
{ {
throw new ArgumentNullException("node"); throw new ArgumentNullException("node");
} }
foreach(XmlNode child in node.ChildNodes) foreach(XmlNode child in node.ChildNodes)
{ {
IDataNode dataNode = Kernel.Instance.ParseNode(child, this); IDataNode dataNode = Kernel.Instance.ParseNode(child, this);
if(dataNode is OptionsNode) if(dataNode is OptionsNode)
{ {
((OptionsNode)dataNode).CopyTo(m_Options); ((OptionsNode)dataNode).CopyTo(m_Options);
} }
} }
} }
/// <summary> /// <summary>
/// Copies to. /// Copies to.
/// </summary> /// </summary>
/// <param name="conf">The conf.</param> /// <param name="conf">The conf.</param>
public void CopyTo(ConfigurationNode conf) public void CopyTo(ConfigurationNode conf)
{ {
m_Options.CopyTo(conf.m_Options); m_Options.CopyTo(conf.m_Options);
} }
#endregion #endregion
#region ICloneable Members #region ICloneable Members
/// <summary> /// <summary>
/// Creates a new object that is a copy of the current instance. /// Creates a new object that is a copy of the current instance.
/// </summary> /// </summary>
/// <returns> /// <returns>
/// A new object that is a copy of this instance. /// A new object that is a copy of this instance.
/// </returns> /// </returns>
public object Clone() public object Clone()
{ {
ConfigurationNode ret = new ConfigurationNode(); ConfigurationNode ret = new ConfigurationNode();
ret.m_Name = m_Name; ret.m_Name = m_Name;
ret.m_Platform = m_Platform; ret.m_Platform = m_Platform;
m_Options.CopyTo(ret.m_Options); m_Options.CopyTo(ret.m_Options);
return ret; return ret;
} }
#endregion #endregion
#region IComparable Members #region IComparable Members
@ -221,5 +221,5 @@ namespace Prebuild.Core.Nodes
} }
#endregion #endregion
} }
} }

72
Prebuild/src/Core/Nodes/ConfigurationNodeCollection.cs
View File

@ -27,45 +27,45 @@ using System.Collections.Generic;
namespace Prebuild.Core.Nodes namespace Prebuild.Core.Nodes
{ {
/// <summary> /// <summary>
/// Implements a specialized list of configuration nodes which allows for lookup via /// Implements a specialized list of configuration nodes which allows for lookup via
/// configuration name and platform. /// configuration name and platform.
/// </summary> /// </summary>
public class ConfigurationNodeCollection : List<ConfigurationNode> public class ConfigurationNodeCollection : List<ConfigurationNode>
{ {
#region Properties #region Properties
public ConfigurationNode this[string nameAndPlatform] public ConfigurationNode this[string nameAndPlatform]
{ {
get get
{ {
foreach (ConfigurationNode configurationNode in this) foreach (ConfigurationNode configurationNode in this)
{ {
if (configurationNode.NameAndPlatform == nameAndPlatform) if (configurationNode.NameAndPlatform == nameAndPlatform)
{ {
return configurationNode; return configurationNode;
} }
} }
return null; return null;
} }
set set
{ {
// See if the node // See if the node
ConfigurationNode configurationNode = this[nameAndPlatform]; ConfigurationNode configurationNode = this[nameAndPlatform];
if (configurationNode != null) if (configurationNode != null)
{ {
this[IndexOf(configurationNode)] = value; this[IndexOf(configurationNode)] = value;
} }
else else
{ {
Add(value); Add(value);
} }
} }
} }
#endregion #endregion
} }
} }

152
Prebuild/src/Core/Nodes/DataNode.cs
View File

@ -32,86 +32,86 @@ using System.IO;
namespace Prebuild.Core.Nodes namespace Prebuild.Core.Nodes
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public abstract class DataNode : IDataNode public abstract class DataNode : IDataNode
{ {
#region Fields #region Fields
private IDataNode parent; private IDataNode parent;
string[] m_WebTypes = new string[] { "aspx", "ascx", "master", "ashx", "asmx" }; string[] m_WebTypes = new string[] { "aspx", "ascx", "master", "ashx", "asmx" };
#endregion #endregion
#region IDataNode Members #region IDataNode Members
/// <summary> /// <summary>
/// Gets or sets the parent. /// Gets or sets the parent.
/// </summary> /// </summary>
/// <value>The parent.</value> /// <value>The parent.</value>
public virtual IDataNode Parent public virtual IDataNode Parent
{ {
get get
{ {
return parent; return parent;
} }
set set
{ {
parent = value; parent = value;
} }
} }
public string[] WebTypes public string[] WebTypes
{ {
get { return m_WebTypes; } get { return m_WebTypes; }
} }
/// <summary> /// <summary>
/// Parses the specified node. /// Parses the specified node.
/// </summary> /// </summary>
/// <param name="node">The node.</param> /// <param name="node">The node.</param>
public virtual void Parse(XmlNode node) public virtual void Parse(XmlNode node)
{ {
} }
public BuildAction GetBuildActionByFileName(string fileName) public BuildAction GetBuildActionByFileName(string fileName)
{ {
string extension = Path.GetExtension(fileName).ToLower(); string extension = Path.GetExtension(fileName).ToLower();
foreach (string type in WebTypes) foreach (string type in WebTypes)
{ {
if (extension == type) if (extension == type)
return BuildAction.Content; return BuildAction.Content;
} }
return BuildAction.Compile; return BuildAction.Compile;
} }
/// <summary> /// <summary>
/// Parses the file type to figure out what type it is /// Parses the file type to figure out what type it is
/// </summary> /// </summary>
/// <returns></returns> /// <returns></returns>
public SubType GetSubTypeByFileName(string fileName) public SubType GetSubTypeByFileName(string fileName)
{ {
string extension = System.IO.Path.GetExtension(fileName).ToLower(); string extension = System.IO.Path.GetExtension(fileName).ToLower();
string designer = String.Format(".designer{0}", extension); string designer = String.Format(".designer{0}", extension);
string path = fileName.ToLower(); string path = fileName.ToLower();
if (extension == ".resx") if (extension == ".resx")
{ {
return SubType.Designer; return SubType.Designer;
} }
else if (path.EndsWith(".settings")) else if (path.EndsWith(".settings"))
{ {
return SubType.Settings; return SubType.Settings;
} }
else else
{ {
foreach (string type in WebTypes) foreach (string type in WebTypes)
{ {
if (path.EndsWith(type)) if (path.EndsWith(type))
{ {
return SubType.CodeBehind; return SubType.CodeBehind;
} }
} }
} }
return SubType.Code; return SubType.Code;
} }
#endregion #endregion
} }
} }

84
Prebuild/src/Core/Nodes/DescriptionNode.cs
View File

@ -32,56 +32,56 @@ using Prebuild.Core.Utilities;
namespace Prebuild.Core.Nodes namespace Prebuild.Core.Nodes
{ {
/// <summary> /// <summary>
/// The object representing the /Prebuild/Solution/Project/Description element /// The object representing the /Prebuild/Solution/Project/Description element
/// </summary> /// </summary>
[DataNode("Description")] [DataNode("Description")]
public class DescriptionNode : DataNode public class DescriptionNode : DataNode
{ {
#region Fields #region Fields
private string m_Value; private string m_Value;
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// Gets the description Value. /// Gets the description Value.
/// </summary> /// </summary>
/// <value>The description Value.</value> /// <value>The description Value.</value>
public string Value public string Value
{ {
get get
{ {
return m_Value; return m_Value;
} }
} }
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// Parses the specified node. /// Parses the specified node.
/// </summary> /// </summary>
/// <param name="node">The node.</param> /// <param name="node">The node.</param>
public override void Parse(XmlNode node) public override void Parse(XmlNode node)
{ {
if( node == null ) if( node == null )
{ {
throw new ArgumentNullException("node"); throw new ArgumentNullException("node");
} }
m_Value = Helper.InterpolateForEnvironmentVariables(node.InnerText); m_Value = Helper.InterpolateForEnvironmentVariables(node.InnerText);
if(m_Value == null) if(m_Value == null)
{ {
m_Value = ""; m_Value = "";
} }
m_Value = m_Value.Trim(); m_Value = m_Value.Trim();
} }
#endregion #endregion
} }
} }

60
Prebuild/src/Core/Nodes/ExcludeNode.cs
View File

@ -32,31 +32,31 @@ using Prebuild.Core.Utilities;
namespace Prebuild.Core.Nodes namespace Prebuild.Core.Nodes
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[DataNode("Exclude")] [DataNode("Exclude")]
public class ExcludeNode : DataNode public class ExcludeNode : DataNode
{ {
#region Fields #region Fields
private string m_Pattern = ""; private string m_Pattern = "";
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// Gets the name. /// Gets the name.
/// </summary> /// </summary>
/// <value>The name.</value> /// <value>The name.</value>
public string Name public string Name
{ {
get get
{ {
return m_Pattern; return m_Pattern;
} }
} }
/// <summary> /// <summary>
/// Gets the pattern. /// Gets the pattern.
@ -72,18 +72,18 @@ namespace Prebuild.Core.Nodes
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// Parses the specified node. /// Parses the specified node.
/// </summary> /// </summary>
/// <param name="node">The node.</param> /// <param name="node">The node.</param>
public override void Parse(XmlNode node) public override void Parse(XmlNode node)
{ {
m_Pattern = Helper.AttributeValue( node, "name", m_Pattern ); m_Pattern = Helper.AttributeValue( node, "name", m_Pattern );
m_Pattern = Helper.AttributeValue(node, "pattern", m_Pattern ); m_Pattern = Helper.AttributeValue(node, "pattern", m_Pattern );
} }
#endregion #endregion
} }
} }

400
Prebuild/src/Core/Nodes/FileNode.cs
View File

@ -34,190 +34,190 @@ using Prebuild.Core.Targets;
namespace Prebuild.Core.Nodes namespace Prebuild.Core.Nodes
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public enum BuildAction public enum BuildAction
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
None, None,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
Compile, Compile,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
Content, Content,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
EmbeddedResource, EmbeddedResource,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
ApplicationDefinition, ApplicationDefinition,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
Page, Page,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
Copy Copy
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public enum SubType public enum SubType
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
Code, Code,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
Component, Component,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
Designer, Designer,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
Form, Form,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
Settings, Settings,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
UserControl, UserControl,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
CodeBehind, CodeBehind,
} }
public enum CopyToOutput public enum CopyToOutput
{ {
Never, Never,
Always, Always,
PreserveNewest PreserveNewest
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[DataNode("File")] [DataNode("File")]
public class FileNode : DataNode public class FileNode : DataNode
{ {
#region Fields #region Fields
private string m_Path; private string m_Path;
private string m_ResourceName = ""; private string m_ResourceName = "";
private BuildAction? m_BuildAction; private BuildAction? m_BuildAction;
private bool m_Valid; private bool m_Valid;
private SubType? m_SubType; private SubType? m_SubType;
private CopyToOutput m_CopyToOutput = CopyToOutput.Never; private CopyToOutput m_CopyToOutput = CopyToOutput.Never;
private bool m_Link = false; private bool m_Link = false;
private string m_LinkPath = string.Empty; private string m_LinkPath = string.Empty;
private bool m_PreservePath = false; private bool m_PreservePath = false;
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public string Path public string Path
{ {
get get
{ {
return m_Path; return m_Path;
} }
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public string ResourceName public string ResourceName
{ {
get get
{ {
return m_ResourceName; return m_ResourceName;
} }
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public BuildAction BuildAction public BuildAction BuildAction
{ {
get get
{ {
if (m_BuildAction != null) if (m_BuildAction != null)
return m_BuildAction.Value; return m_BuildAction.Value;
else else
return GetBuildActionByFileName(this.Path); return GetBuildActionByFileName(this.Path);
} }
} }
public CopyToOutput CopyToOutput public CopyToOutput CopyToOutput
{ {
get get
{ {
return this.m_CopyToOutput; return this.m_CopyToOutput;
} }
} }
public bool IsLink public bool IsLink
{ {
get get
{ {
return this.m_Link; return this.m_Link;
} }
} }
public string LinkPath public string LinkPath
{ {
get get
{ {
return this.m_LinkPath; return this.m_LinkPath;
} }
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public SubType SubType public SubType SubType
{ {
get get
{ {
if (m_SubType != null) if (m_SubType != null)
return m_SubType.Value; return m_SubType.Value;
else else
return GetSubTypeByFileName(this.Path); return GetSubTypeByFileName(this.Path);
} }
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public bool IsValid public bool IsValid
{ {
get get
{ {
return m_Valid; return m_Valid;
} }
} }
/// <summary> /// <summary>
/// ///
@ -232,61 +232,61 @@ namespace Prebuild.Core.Nodes
} }
} }
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
/// <param name="node"></param> /// <param name="node"></param>
public override void Parse(XmlNode node) public override void Parse(XmlNode node)
{ {
string buildAction = Helper.AttributeValue(node, "buildAction", String.Empty); string buildAction = Helper.AttributeValue(node, "buildAction", String.Empty);
if (buildAction != string.Empty) if (buildAction != string.Empty)
m_BuildAction = (BuildAction)Enum.Parse(typeof(BuildAction), buildAction); m_BuildAction = (BuildAction)Enum.Parse(typeof(BuildAction), buildAction);
string subType = Helper.AttributeValue(node, "subType", string.Empty); string subType = Helper.AttributeValue(node, "subType", string.Empty);
if (subType != String.Empty) if (subType != String.Empty)
m_SubType = (SubType)Enum.Parse(typeof(SubType), subType); m_SubType = (SubType)Enum.Parse(typeof(SubType), subType);
Console.WriteLine("[FileNode]:BuildAction is {0}", buildAction); Console.WriteLine("[FileNode]:BuildAction is {0}", buildAction);
m_ResourceName = Helper.AttributeValue(node, "resourceName", m_ResourceName.ToString()); m_ResourceName = Helper.AttributeValue(node, "resourceName", m_ResourceName.ToString());
this.m_Link = bool.Parse(Helper.AttributeValue(node, "link", bool.FalseString)); this.m_Link = bool.Parse(Helper.AttributeValue(node, "link", bool.FalseString));
if ( this.m_Link == true ) if ( this.m_Link == true )
{ {
this.m_LinkPath = Helper.AttributeValue( node, "linkPath", string.Empty ); this.m_LinkPath = Helper.AttributeValue( node, "linkPath", string.Empty );
} }
this.m_CopyToOutput = (CopyToOutput) Enum.Parse(typeof(CopyToOutput), Helper.AttributeValue(node, "copyToOutput", this.m_CopyToOutput.ToString())); this.m_CopyToOutput = (CopyToOutput) Enum.Parse(typeof(CopyToOutput), Helper.AttributeValue(node, "copyToOutput", this.m_CopyToOutput.ToString()));
this.m_PreservePath = bool.Parse( Helper.AttributeValue( node, "preservePath", bool.FalseString ) ); this.m_PreservePath = bool.Parse( Helper.AttributeValue( node, "preservePath", bool.FalseString ) );
if( node == null ) if( node == null )
{ {
throw new ArgumentNullException("node"); throw new ArgumentNullException("node");
} }
m_Path = Helper.InterpolateForEnvironmentVariables(node.InnerText); m_Path = Helper.InterpolateForEnvironmentVariables(node.InnerText);
if(m_Path == null) if(m_Path == null)
{ {
m_Path = ""; m_Path = "";
} }
m_Path = m_Path.Trim(); m_Path = m_Path.Trim();
m_Valid = true; m_Valid = true;
if(!File.Exists(m_Path)) if(!File.Exists(m_Path))
{ {
m_Valid = false; m_Valid = false;
Kernel.Instance.Log.Write(LogType.Warning, "File does not exist: {0}", m_Path); Kernel.Instance.Log.Write(LogType.Warning, "File does not exist: {0}", m_Path);
} }
if (System.IO.Path.GetExtension(m_Path) == ".settings") if (System.IO.Path.GetExtension(m_Path) == ".settings")
{ {
m_SubType = SubType.Settings; m_SubType = SubType.Settings;
m_BuildAction = BuildAction.None; m_BuildAction = BuildAction.None;
} }
} }
#endregion #endregion
} }
} }

244
Prebuild/src/Core/Nodes/FilesNode.cs
View File

@ -34,36 +34,36 @@ using System.IO;
namespace Prebuild.Core.Nodes namespace Prebuild.Core.Nodes
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[DataNode("Files")] [DataNode("Files")]
public class FilesNode : DataNode public class FilesNode : DataNode
{ {
#region Fields #region Fields
private readonly List<string> m_Files = new List<string>(); private readonly List<string> m_Files = new List<string>();
private readonly Dictionary<string,BuildAction> m_BuildActions = new Dictionary<string, BuildAction>(); private readonly Dictionary<string,BuildAction> m_BuildActions = new Dictionary<string, BuildAction>();
private readonly Dictionary<string, SubType> m_SubTypes = new Dictionary<string, SubType>(); private readonly Dictionary<string, SubType> m_SubTypes = new Dictionary<string, SubType>();
private readonly Dictionary<string, string> m_ResourceNames = new Dictionary<string, string>(); private readonly Dictionary<string, string> m_ResourceNames = new Dictionary<string, string>();
private readonly Dictionary<string, CopyToOutput> m_CopyToOutputs = new Dictionary<string, CopyToOutput>(); private readonly Dictionary<string, CopyToOutput> m_CopyToOutputs = new Dictionary<string, CopyToOutput>();
private readonly Dictionary<string, bool> m_Links = new Dictionary<string, bool>(); private readonly Dictionary<string, bool> m_Links = new Dictionary<string, bool>();
private readonly Dictionary<string, string> m_LinkPaths = new Dictionary<string, string>(); private readonly Dictionary<string, string> m_LinkPaths = new Dictionary<string, string>();
private readonly Dictionary<string, bool> m_PreservePaths = new Dictionary<string, bool>(); private readonly Dictionary<string, bool> m_PreservePaths = new Dictionary<string, bool>();
private readonly Dictionary<string, string> m_DestinationPath = new Dictionary<string, string>(); private readonly Dictionary<string, string> m_DestinationPath = new Dictionary<string, string>();
private readonly NameValueCollection m_CopyFiles = new NameValueCollection(); private readonly NameValueCollection m_CopyFiles = new NameValueCollection();
#endregion #endregion
#region Properties #region Properties
public int Count public int Count
{ {
get get
{ {
return m_Files.Count; return m_Files.Count;
} }
} }
public string[] Destinations public string[] Destinations
{ {
@ -75,19 +75,19 @@ namespace Prebuild.Core.Nodes
get { return m_CopyFiles.Count; } get { return m_CopyFiles.Count; }
} }
#endregion #endregion
#region Public Methods #region Public Methods
public BuildAction GetBuildAction(string file) public BuildAction GetBuildAction(string file)
{ {
if(!m_BuildActions.ContainsKey(file)) if(!m_BuildActions.ContainsKey(file))
{ {
return BuildAction.Compile; return BuildAction.Compile;
} }
return m_BuildActions[file]; return m_BuildActions[file];
} }
public string GetDestinationPath(string file) public string GetDestinationPath(string file)
{ {
@ -103,57 +103,57 @@ namespace Prebuild.Core.Nodes
return m_CopyFiles.GetValues(dest); return m_CopyFiles.GetValues(dest);
} }
public CopyToOutput GetCopyToOutput(string file) public CopyToOutput GetCopyToOutput(string file)
{ {
if (!m_CopyToOutputs.ContainsKey(file)) if (!m_CopyToOutputs.ContainsKey(file))
{ {
return CopyToOutput.Never; return CopyToOutput.Never;
} }
return m_CopyToOutputs[file]; return m_CopyToOutputs[file];
} }
public bool GetIsLink(string file) public bool GetIsLink(string file)
{ {
if (!m_Links.ContainsKey(file)) if (!m_Links.ContainsKey(file))
{ {
return false; return false;
} }
return m_Links[file]; return m_Links[file];
} }
public bool Contains(string file) public bool Contains(string file)
{ {
return m_Files.Contains(file); return m_Files.Contains(file);
} }
public string GetLinkPath( string file ) public string GetLinkPath( string file )
{ {
if ( !m_LinkPaths.ContainsKey( file ) ) if ( !m_LinkPaths.ContainsKey( file ) )
{ {
return string.Empty; return string.Empty;
} }
return m_LinkPaths[ file ]; return m_LinkPaths[ file ];
} }
public SubType GetSubType(string file) public SubType GetSubType(string file)
{ {
if(!m_SubTypes.ContainsKey(file)) if(!m_SubTypes.ContainsKey(file))
{ {
return SubType.Code; return SubType.Code;
} }
return m_SubTypes[file]; return m_SubTypes[file];
} }
public string GetResourceName(string file) public string GetResourceName(string file)
{ {
if(!m_ResourceNames.ContainsKey(file)) if(!m_ResourceNames.ContainsKey(file))
{ {
return string.Empty; return string.Empty;
} }
return m_ResourceNames[file]; return m_ResourceNames[file];
} }
public bool GetPreservePath( string file ) public bool GetPreservePath( string file )
{ {
@ -165,45 +165,45 @@ namespace Prebuild.Core.Nodes
return m_PreservePaths[ file ]; return m_PreservePaths[ file ];
} }
public override void Parse(XmlNode node) public override void Parse(XmlNode node)
{ {
if( node == null ) if( node == null )
{ {
throw new ArgumentNullException("node"); throw new ArgumentNullException("node");
} }
foreach(XmlNode child in node.ChildNodes) foreach(XmlNode child in node.ChildNodes)
{ {
IDataNode dataNode = Kernel.Instance.ParseNode(child, this); IDataNode dataNode = Kernel.Instance.ParseNode(child, this);
if(dataNode is FileNode) if(dataNode is FileNode)
{ {
FileNode fileNode = (FileNode)dataNode; FileNode fileNode = (FileNode)dataNode;
if(fileNode.IsValid) if(fileNode.IsValid)
{ {
if (!m_Files.Contains(fileNode.Path)) if (!m_Files.Contains(fileNode.Path))
{ {
m_Files.Add(fileNode.Path); m_Files.Add(fileNode.Path);
m_BuildActions[fileNode.Path] = fileNode.BuildAction; m_BuildActions[fileNode.Path] = fileNode.BuildAction;
m_SubTypes[fileNode.Path] = fileNode.SubType; m_SubTypes[fileNode.Path] = fileNode.SubType;
m_ResourceNames[fileNode.Path] = fileNode.ResourceName; m_ResourceNames[fileNode.Path] = fileNode.ResourceName;
m_PreservePaths[ fileNode.Path ] = fileNode.PreservePath; m_PreservePaths[ fileNode.Path ] = fileNode.PreservePath;
m_Links[ fileNode.Path ] = fileNode.IsLink; m_Links[ fileNode.Path ] = fileNode.IsLink;
m_LinkPaths[ fileNode.Path ] = fileNode.LinkPath; m_LinkPaths[ fileNode.Path ] = fileNode.LinkPath;
m_CopyToOutputs[ fileNode.Path ] = fileNode.CopyToOutput; m_CopyToOutputs[ fileNode.Path ] = fileNode.CopyToOutput;
} }
} }
} }
else if(dataNode is MatchNode) else if(dataNode is MatchNode)
{ {
foreach(string file in ((MatchNode)dataNode).Files) foreach(string file in ((MatchNode)dataNode).Files)
{ {
MatchNode matchNode = (MatchNode)dataNode; MatchNode matchNode = (MatchNode)dataNode;
if (!m_Files.Contains(file)) if (!m_Files.Contains(file))
{ {
m_Files.Add(file); m_Files.Add(file);
if (matchNode.BuildAction == null) if (matchNode.BuildAction == null)
m_BuildActions[file] = GetBuildActionByFileName(file); m_BuildActions[file] = GetBuildActionByFileName(file);
else else
m_BuildActions[file] = matchNode.BuildAction.Value; m_BuildActions[file] = matchNode.BuildAction.Value;
if (matchNode.BuildAction == BuildAction.Copy) if (matchNode.BuildAction == BuildAction.Copy)
@ -212,27 +212,27 @@ namespace Prebuild.Core.Nodes
m_DestinationPath[file] = matchNode.DestinationPath; m_DestinationPath[file] = matchNode.DestinationPath;
} }
m_SubTypes[file] = matchNode.SubType == null ? GetSubTypeByFileName(file) : matchNode.SubType.Value; m_SubTypes[file] = matchNode.SubType == null ? GetSubTypeByFileName(file) : matchNode.SubType.Value;
m_ResourceNames[ file ] = matchNode.ResourceName; m_ResourceNames[ file ] = matchNode.ResourceName;
m_PreservePaths[ file ] = matchNode.PreservePath; m_PreservePaths[ file ] = matchNode.PreservePath;
m_Links[ file ] = matchNode.IsLink; m_Links[ file ] = matchNode.IsLink;
m_LinkPaths[ file ] = matchNode.LinkPath; m_LinkPaths[ file ] = matchNode.LinkPath;
m_CopyToOutputs[ file ] = matchNode.CopyToOutput; m_CopyToOutputs[ file ] = matchNode.CopyToOutput;
} }
} }
} }
} }
} }
// TODO: Check in to why StringCollection's enumerator doesn't implement // TODO: Check in to why StringCollection's enumerator doesn't implement
// IEnumerator? // IEnumerator?
public IEnumerator<string> GetEnumerator() public IEnumerator<string> GetEnumerator()
{ {
return m_Files.GetEnumerator(); return m_Files.GetEnumerator();
} }
#endregion #endregion
} }
} }

394
Prebuild/src/Core/Nodes/MatchNode.cs
View File

@ -35,51 +35,51 @@ using Prebuild.Core.Utilities;
namespace Prebuild.Core.Nodes namespace Prebuild.Core.Nodes
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[DataNode("Match")] [DataNode("Match")]
public class MatchNode : DataNode public class MatchNode : DataNode
{ {
#region Fields #region Fields
private readonly List<string> m_Files = new List<string>(); private readonly List<string> m_Files = new List<string>();
private Regex m_Regex; private Regex m_Regex;
private BuildAction? m_BuildAction; private BuildAction? m_BuildAction;
private SubType? m_SubType; private SubType? m_SubType;
string m_ResourceName = ""; string m_ResourceName = "";
private CopyToOutput m_CopyToOutput; private CopyToOutput m_CopyToOutput;
private bool m_Link; private bool m_Link;
private string m_LinkPath; private string m_LinkPath;
private bool m_PreservePath; private bool m_PreservePath;
private string m_Destination = ""; private string m_Destination = "";
private readonly List<ExcludeNode> m_Exclusions = new List<ExcludeNode>(); private readonly List<ExcludeNode> m_Exclusions = new List<ExcludeNode>();
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public IEnumerable<string> Files public IEnumerable<string> Files
{ {
get get
{ {
return m_Files; return m_Files;
} }
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public BuildAction? BuildAction public BuildAction? BuildAction
{ {
get get
{ {
return m_BuildAction; return m_BuildAction;
} }
} }
public string DestinationPath public string DestinationPath
{ {
@ -88,50 +88,50 @@ namespace Prebuild.Core.Nodes
return m_Destination; return m_Destination;
} }
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public SubType? SubType public SubType? SubType
{ {
get get
{ {
return m_SubType; return m_SubType;
} }
} }
public CopyToOutput CopyToOutput public CopyToOutput CopyToOutput
{ {
get get
{ {
return m_CopyToOutput; return m_CopyToOutput;
} }
} }
public bool IsLink public bool IsLink
{ {
get get
{ {
return m_Link; return m_Link;
} }
} }
public string LinkPath public string LinkPath
{ {
get get
{ {
return m_LinkPath; return m_LinkPath;
} }
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public string ResourceName public string ResourceName
{ {
get get
{ {
return m_ResourceName; return m_ResourceName;
} }
} }
public bool PreservePath public bool PreservePath
{ {
@ -141,27 +141,27 @@ namespace Prebuild.Core.Nodes
} }
} }
#endregion #endregion
#region Private Methods #region Private Methods
/// <summary> /// <summary>
/// Recurses the directories. /// Recurses the directories.
/// </summary> /// </summary>
/// <param name="path">The path.</param> /// <param name="path">The path.</param>
/// <param name="pattern">The pattern.</param> /// <param name="pattern">The pattern.</param>
/// <param name="recurse">if set to <c>true</c> [recurse].</param> /// <param name="recurse">if set to <c>true</c> [recurse].</param>
/// <param name="useRegex">if set to <c>true</c> [use regex].</param> /// <param name="useRegex">if set to <c>true</c> [use regex].</param>
private void RecurseDirectories(string path, string pattern, bool recurse, bool useRegex, List<ExcludeNode> exclusions) private void RecurseDirectories(string path, string pattern, bool recurse, bool useRegex, List<ExcludeNode> exclusions)
{ {
Match match; Match match;
try try
{ {
string[] files; string[] files;
Boolean excludeFile; Boolean excludeFile;
if(!useRegex) if(!useRegex)
{ {
try try
{ {
files = Directory.GetFiles(path, pattern); files = Directory.GetFiles(path, pattern);
@ -177,20 +177,20 @@ namespace Prebuild.Core.Nodes
files = null; files = null;
} }
if(files != null) if(files != null)
{ {
foreach (string file in files) foreach (string file in files)
{ {
excludeFile = false; excludeFile = false;
string fileTemp; string fileTemp;
if (file.Substring(0,2) == "./" || file.Substring(0,2) == ".\\") if (file.Substring(0,2) == "./" || file.Substring(0,2) == ".\\")
{ {
fileTemp = file.Substring(2); fileTemp = file.Substring(2);
} }
else else
{ {
fileTemp = file; fileTemp = file;
} }
// Check all excludions and set flag if there are any hits. // Check all excludions and set flag if there are any hits.
foreach ( ExcludeNode exclude in exclusions ) foreach ( ExcludeNode exclude in exclusions )
@ -205,18 +205,18 @@ namespace Prebuild.Core.Nodes
m_Files.Add( fileTemp ); m_Files.Add( fileTemp );
} }
} }
} }
// don't call return here, because we may need to recursively search directories below // don't call return here, because we may need to recursively search directories below
// this one, even if no matches were found in this directory. // this one, even if no matches were found in this directory.
} }
else else
{ {
try try
{ {
files = Directory.GetFiles(path); files = Directory.GetFiles(path);
} }
catch (IOException) catch (IOException)
{ {
// swallow weird IOException error when running in a virtual box // swallow weird IOException error when running in a virtual box
@ -248,12 +248,12 @@ namespace Prebuild.Core.Nodes
} }
} }
} }
} }
if(recurse) if(recurse)
{ {
string[] dirs = Directory.GetDirectories(path); string[] dirs = Directory.GetDirectories(path);
if(dirs != null && dirs.Length > 0) if(dirs != null && dirs.Length > 0)
{ {
foreach (string str in dirs) foreach (string str in dirs)
{ {
@ -265,96 +265,96 @@ namespace Prebuild.Core.Nodes
RecurseDirectories(Helper.NormalizePath(str), pattern, recurse, useRegex, exclusions); RecurseDirectories(Helper.NormalizePath(str), pattern, recurse, useRegex, exclusions);
} }
} }
} }
} }
catch(DirectoryNotFoundException) catch(DirectoryNotFoundException)
{ {
return; return;
} }
catch(ArgumentException) catch(ArgumentException)
{ {
return; return;
} }
} }
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
/// <param name="node"></param> /// <param name="node"></param>
public override void Parse(XmlNode node) public override void Parse(XmlNode node)
{ {
if( node == null ) if( node == null )
{ {
throw new ArgumentNullException("node"); throw new ArgumentNullException("node");
} }
string path = Helper.AttributeValue(node, "path", "."); string path = Helper.AttributeValue(node, "path", ".");
string pattern = Helper.AttributeValue(node, "pattern", "*"); string pattern = Helper.AttributeValue(node, "pattern", "*");
string destination = Helper.AttributeValue(node, "destination", string.Empty); string destination = Helper.AttributeValue(node, "destination", string.Empty);
bool recurse = (bool)Helper.TranslateValue(typeof(bool), Helper.AttributeValue(node, "recurse", "false")); bool recurse = (bool)Helper.TranslateValue(typeof(bool), Helper.AttributeValue(node, "recurse", "false"));
bool useRegex = (bool)Helper.TranslateValue(typeof(bool), Helper.AttributeValue(node, "useRegex", "false")); bool useRegex = (bool)Helper.TranslateValue(typeof(bool), Helper.AttributeValue(node, "useRegex", "false"));
string buildAction = Helper.AttributeValue(node, "buildAction", String.Empty); string buildAction = Helper.AttributeValue(node, "buildAction", String.Empty);
if (buildAction != string.Empty) if (buildAction != string.Empty)
m_BuildAction = (BuildAction)Enum.Parse(typeof(BuildAction), buildAction); m_BuildAction = (BuildAction)Enum.Parse(typeof(BuildAction), buildAction);
//TODO: Figure out where the subtype node is being assigned //TODO: Figure out where the subtype node is being assigned
//string subType = Helper.AttributeValue(node, "subType", string.Empty); //string subType = Helper.AttributeValue(node, "subType", string.Empty);
//if (subType != String.Empty) //if (subType != String.Empty)
// m_SubType = (SubType)Enum.Parse(typeof(SubType), subType); // m_SubType = (SubType)Enum.Parse(typeof(SubType), subType);
m_ResourceName = Helper.AttributeValue(node, "resourceName", m_ResourceName); m_ResourceName = Helper.AttributeValue(node, "resourceName", m_ResourceName);
m_CopyToOutput = (CopyToOutput) Enum.Parse(typeof(CopyToOutput), Helper.AttributeValue(node, "copyToOutput", m_CopyToOutput.ToString())); m_CopyToOutput = (CopyToOutput) Enum.Parse(typeof(CopyToOutput), Helper.AttributeValue(node, "copyToOutput", m_CopyToOutput.ToString()));
m_Link = bool.Parse(Helper.AttributeValue(node, "link", bool.FalseString)); m_Link = bool.Parse(Helper.AttributeValue(node, "link", bool.FalseString));
if ( m_Link ) if ( m_Link )
{ {
m_LinkPath = Helper.AttributeValue( node, "linkPath", string.Empty ); m_LinkPath = Helper.AttributeValue( node, "linkPath", string.Empty );
} }
m_PreservePath = bool.Parse( Helper.AttributeValue( node, "preservePath", bool.FalseString ) ); m_PreservePath = bool.Parse( Helper.AttributeValue( node, "preservePath", bool.FalseString ) );
if ( buildAction == "Copy") if ( buildAction == "Copy")
m_Destination = destination; m_Destination = destination;
if(path != null && path.Length == 0) if(path != null && path.Length == 0)
path = ".";//use current directory path = ".";//use current directory
//throw new WarningException("Match must have a 'path' attribute"); //throw new WarningException("Match must have a 'path' attribute");
if(pattern == null) if(pattern == null)
{ {
throw new WarningException("Match must have a 'pattern' attribute"); throw new WarningException("Match must have a 'pattern' attribute");
} }
path = Helper.NormalizePath(path); path = Helper.NormalizePath(path);
if(!Directory.Exists(path)) if(!Directory.Exists(path))
{ {
throw new WarningException("Match path does not exist: {0}", path); throw new WarningException("Match path does not exist: {0}", path);
} }
try try
{ {
if(useRegex) if(useRegex)
{ {
m_Regex = new Regex(pattern); m_Regex = new Regex(pattern);
} }
} }
catch(ArgumentException ex) catch(ArgumentException ex)
{ {
throw new WarningException("Could not compile regex pattern: {0}", ex.Message); throw new WarningException("Could not compile regex pattern: {0}", ex.Message);
} }
foreach(XmlNode child in node.ChildNodes) foreach(XmlNode child in node.ChildNodes)
{ {
IDataNode dataNode = Kernel.Instance.ParseNode(child, this); IDataNode dataNode = Kernel.Instance.ParseNode(child, this);
if(dataNode is ExcludeNode) if(dataNode is ExcludeNode)
{ {
ExcludeNode excludeNode = (ExcludeNode)dataNode; ExcludeNode excludeNode = (ExcludeNode)dataNode;
m_Exclusions.Add( excludeNode ); m_Exclusions.Add( excludeNode );
} }
} }
RecurseDirectories( path, pattern, recurse, useRegex, m_Exclusions ); RecurseDirectories( path, pattern, recurse, useRegex, m_Exclusions );
@ -371,8 +371,8 @@ namespace Prebuild.Core.Nodes
throw new WarningException("Match" + projectName + " returned no files: {0}{1}", Helper.EndPath(path), pattern); throw new WarningException("Match" + projectName + " returned no files: {0}{1}", Helper.EndPath(path), pattern);
} }
m_Regex = null; m_Regex = null;
} }
#endregion #endregion
} }
} }

1012
Prebuild/src/Core/Nodes/OptionsNode.cs
View File

File diff suppressed because it is too large Load Diff

124
Prebuild/src/Core/Nodes/ProcessNode.cs
View File

@ -32,77 +32,77 @@ using Prebuild.Core.Utilities;
namespace Prebuild.Core.Nodes namespace Prebuild.Core.Nodes
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[DataNode("Process")] [DataNode("Process")]
public class ProcessNode : DataNode public class ProcessNode : DataNode
{ {
#region Fields #region Fields
private string m_Path; private string m_Path;
private bool m_IsValid = true; private bool m_IsValid = true;
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// Gets the path. /// Gets the path.
/// </summary> /// </summary>
/// <value>The path.</value> /// <value>The path.</value>
public string Path public string Path
{ {
get get
{ {
return m_Path; return m_Path;
} }
} }
/// <summary> /// <summary>
/// Gets a value indicating whether this instance is valid. /// Gets a value indicating whether this instance is valid.
/// </summary> /// </summary>
/// <value><c>true</c> if this instance is valid; otherwise, <c>false</c>.</value> /// <value><c>true</c> if this instance is valid; otherwise, <c>false</c>.</value>
public bool IsValid public bool IsValid
{ {
get get
{ {
return m_IsValid; return m_IsValid;
} }
} }
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// Parses the specified node. /// Parses the specified node.
/// </summary> /// </summary>
/// <param name="node">The node.</param> /// <param name="node">The node.</param>
public override void Parse(XmlNode node) public override void Parse(XmlNode node)
{ {
if( node == null ) if( node == null )
{ {
throw new ArgumentNullException("node"); throw new ArgumentNullException("node");
} }
m_Path = Helper.InterpolateForEnvironmentVariables(node.InnerText); m_Path = Helper.InterpolateForEnvironmentVariables(node.InnerText);
if(m_Path == null) if(m_Path == null)
{ {
m_Path = ""; m_Path = "";
} }
try try
{ {
m_Path = Helper.ResolvePath(m_Path); m_Path = Helper.ResolvePath(m_Path);
} }
catch(ArgumentException) catch(ArgumentException)
{ {
Kernel.Instance.Log.Write(LogType.Warning, "Could not find prebuild file for processing: {0}", m_Path); Kernel.Instance.Log.Write(LogType.Warning, "Could not find prebuild file for processing: {0}", m_Path);
m_IsValid = false; m_IsValid = false;
} }
} }
#endregion #endregion
} }
} }

908
Prebuild/src/Core/Nodes/ProjectNode.cs
View File

File diff suppressed because it is too large Load Diff

174
Prebuild/src/Core/Nodes/ReferenceNode.cs
View File

@ -32,104 +32,104 @@ using Prebuild.Core.Utilities;
namespace Prebuild.Core.Nodes namespace Prebuild.Core.Nodes
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[DataNode("Reference")] [DataNode("Reference")]
public class ReferenceNode : DataNode, IComparable public class ReferenceNode : DataNode, IComparable
{ {
#region Fields #region Fields
private string m_Name = "unknown"; private string m_Name = "unknown";
private string m_Path; private string m_Path;
private string m_LocalCopy; private string m_LocalCopy;
private string m_Version; private string m_Version;
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// Gets the name. /// Gets the name.
/// </summary> /// </summary>
/// <value>The name.</value> /// <value>The name.</value>
public string Name public string Name
{ {
get get
{ {
return m_Name; return m_Name;
} }
} }
/// <summary> /// <summary>
/// Gets the path. /// Gets the path.
/// </summary> /// </summary>
/// <value>The path.</value> /// <value>The path.</value>
public string Path public string Path
{ {
get get
{ {
return m_Path; return m_Path;
} }
} }
/// <summary> /// <summary>
/// Gets a value indicating whether [local copy specified]. /// Gets a value indicating whether [local copy specified].
/// </summary> /// </summary>
/// <value><c>true</c> if [local copy specified]; otherwise, <c>false</c>.</value> /// <value><c>true</c> if [local copy specified]; otherwise, <c>false</c>.</value>
public bool LocalCopySpecified public bool LocalCopySpecified
{ {
get get
{ {
return ( m_LocalCopy != null && m_LocalCopy.Length == 0); return ( m_LocalCopy != null && m_LocalCopy.Length == 0);
} }
} }
/// <summary> /// <summary>
/// Gets a value indicating whether [local copy]. /// Gets a value indicating whether [local copy].
/// </summary> /// </summary>
/// <value><c>true</c> if [local copy]; otherwise, <c>false</c>.</value> /// <value><c>true</c> if [local copy]; otherwise, <c>false</c>.</value>
public bool LocalCopy public bool LocalCopy
{ {
get get
{ {
if( m_LocalCopy == null) if( m_LocalCopy == null)
{ {
return false; return false;
} }
return bool.Parse(m_LocalCopy); return bool.Parse(m_LocalCopy);
} }
} }
/// <summary> /// <summary>
/// Gets the version. /// Gets the version.
/// </summary> /// </summary>
/// <value>The version.</value> /// <value>The version.</value>
public string Version public string Version
{ {
get get
{ {
return m_Version; return m_Version;
} }
} }
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// Parses the specified node. /// Parses the specified node.
/// </summary> /// </summary>
/// <param name="node">The node.</param> /// <param name="node">The node.</param>
public override void Parse(XmlNode node) public override void Parse(XmlNode node)
{ {
m_Name = Helper.AttributeValue(node, "name", m_Name); m_Name = Helper.AttributeValue(node, "name", m_Name);
m_Path = Helper.AttributeValue(node, "path", m_Path); m_Path = Helper.AttributeValue(node, "path", m_Path);
m_LocalCopy = Helper.AttributeValue(node, "localCopy", m_LocalCopy); m_LocalCopy = Helper.AttributeValue(node, "localCopy", m_LocalCopy);
m_Version = Helper.AttributeValue(node, "version", m_Version); m_Version = Helper.AttributeValue(node, "version", m_Version);
} }
#endregion #endregion
#region IComparable Members #region IComparable Members
@ -140,5 +140,5 @@ namespace Prebuild.Core.Nodes
} }
#endregion #endregion
} }
} }

84
Prebuild/src/Core/Nodes/ReferencePathNode.cs
View File

@ -32,57 +32,57 @@ using Prebuild.Core.Utilities;
namespace Prebuild.Core.Nodes namespace Prebuild.Core.Nodes
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[DataNode("ReferencePath")] [DataNode("ReferencePath")]
public class ReferencePathNode : DataNode, IComparable public class ReferencePathNode : DataNode, IComparable
{ {
#region Fields #region Fields
private string m_Path; private string m_Path;
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// Gets the path. /// Gets the path.
/// </summary> /// </summary>
/// <value>The path.</value> /// <value>The path.</value>
public string Path public string Path
{ {
get get
{ {
return m_Path; return m_Path;
} }
} }
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// Parses the specified node. /// Parses the specified node.
/// </summary> /// </summary>
/// <param name="node">The node.</param> /// <param name="node">The node.</param>
public override void Parse(XmlNode node) public override void Parse(XmlNode node)
{ {
if( node == null ) if( node == null )
{ {
throw new ArgumentNullException("node"); throw new ArgumentNullException("node");
} }
m_Path = Helper.InterpolateForEnvironmentVariables(node.InnerText); m_Path = Helper.InterpolateForEnvironmentVariables(node.InnerText);
if(m_Path == null) if(m_Path == null)
{ {
m_Path = ""; m_Path = "";
} }
m_Path = m_Path.Trim(); m_Path = m_Path.Trim();
} }
#endregion #endregion
#region IComparable Members #region IComparable Members
@ -93,5 +93,5 @@ namespace Prebuild.Core.Nodes
} }
#endregion #endregion
} }
} }

448
Prebuild/src/Core/Nodes/SolutionNode.cs
View File

@ -34,35 +34,35 @@ using Prebuild.Core.Utilities;
namespace Prebuild.Core.Nodes namespace Prebuild.Core.Nodes
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[DataNode("Solution")] [DataNode("Solution")]
[DataNode("EmbeddedSolution")] [DataNode("EmbeddedSolution")]
[DebuggerDisplay("{Name}")] [DebuggerDisplay("{Name}")]
public class SolutionNode : DataNode public class SolutionNode : DataNode
{ {
#region Fields #region Fields
private Guid m_Guid = Guid.NewGuid(); private Guid m_Guid = Guid.NewGuid();
private string m_Name = "unknown"; private string m_Name = "unknown";
private string m_Path = ""; private string m_Path = "";
private string m_FullPath = ""; private string m_FullPath = "";
private string m_ActiveConfig; private string m_ActiveConfig;
private string m_Version = "1.0.0"; private string m_Version = "1.0.0";
private OptionsNode m_Options; private OptionsNode m_Options;
private FilesNode m_Files; private FilesNode m_Files;
private readonly ConfigurationNodeCollection m_Configurations = new ConfigurationNodeCollection(); private readonly ConfigurationNodeCollection m_Configurations = new ConfigurationNodeCollection();
private readonly Dictionary<string, ProjectNode> m_Projects = new Dictionary<string, ProjectNode>(); private readonly Dictionary<string, ProjectNode> m_Projects = new Dictionary<string, ProjectNode>();
private readonly Dictionary<string, DatabaseProjectNode> m_DatabaseProjects = new Dictionary<string, DatabaseProjectNode>(); private readonly Dictionary<string, DatabaseProjectNode> m_DatabaseProjects = new Dictionary<string, DatabaseProjectNode>();
private readonly List<ProjectNode> m_ProjectsOrder = new List<ProjectNode>(); private readonly List<ProjectNode> m_ProjectsOrder = new List<ProjectNode>();
private readonly Dictionary<string, SolutionNode> m_Solutions = new Dictionary<string, SolutionNode>(); private readonly Dictionary<string, SolutionNode> m_Solutions = new Dictionary<string, SolutionNode>();
private CleanupNode m_Cleanup; private CleanupNode m_Cleanup;
#endregion #endregion
#region Properties #region Properties
public override IDataNode Parent public override IDataNode Parent
{ {
get get
@ -84,17 +84,17 @@ namespace Prebuild.Core.Nodes
} }
} }
public CleanupNode Cleanup public CleanupNode Cleanup
{ {
get get
{ {
return m_Cleanup; return m_Cleanup;
} }
set set
{ {
m_Cleanup = value; m_Cleanup = value;
} }
} }
public Guid Guid public Guid Guid
{ {
@ -107,119 +107,119 @@ namespace Prebuild.Core.Nodes
m_Guid = value; m_Guid = value;
} }
} }
/// <summary> /// <summary>
/// Gets or sets the active config. /// Gets or sets the active config.
/// </summary> /// </summary>
/// <value>The active config.</value> /// <value>The active config.</value>
public string ActiveConfig public string ActiveConfig
{ {
get get
{ {
return m_ActiveConfig; return m_ActiveConfig;
} }
set set
{ {
m_ActiveConfig = value; m_ActiveConfig = value;
} }
} }
/// <summary> /// <summary>
/// Gets the name. /// Gets the name.
/// </summary> /// </summary>
/// <value>The name.</value> /// <value>The name.</value>
public string Name public string Name
{ {
get get
{ {
return m_Name; return m_Name;
} }
} }
/// <summary> /// <summary>
/// Gets the path. /// Gets the path.
/// </summary> /// </summary>
/// <value>The path.</value> /// <value>The path.</value>
public string Path public string Path
{ {
get get
{ {
return m_Path; return m_Path;
} }
} }
/// <summary> /// <summary>
/// Gets the full path. /// Gets the full path.
/// </summary> /// </summary>
/// <value>The full path.</value> /// <value>The full path.</value>
public string FullPath public string FullPath
{ {
get get
{ {
return m_FullPath; return m_FullPath;
} }
} }
/// <summary> /// <summary>
/// Gets the version. /// Gets the version.
/// </summary> /// </summary>
/// <value>The version.</value> /// <value>The version.</value>
public string Version public string Version
{ {
get get
{ {
return m_Version; return m_Version;
} }
} }
/// <summary> /// <summary>
/// Gets the options. /// Gets the options.
/// </summary> /// </summary>
/// <value>The options.</value> /// <value>The options.</value>
public OptionsNode Options public OptionsNode Options
{ {
get get
{ {
return m_Options; return m_Options;
} }
} }
/// <summary> /// <summary>
/// Gets the files. /// Gets the files.
/// </summary> /// </summary>
/// <value>The files.</value> /// <value>The files.</value>
public FilesNode Files public FilesNode Files
{ {
get get
{ {
return m_Files; return m_Files;
} }
} }
/// <summary> /// <summary>
/// Gets the configurations. /// Gets the configurations.
/// </summary> /// </summary>
/// <value>The configurations.</value> /// <value>The configurations.</value>
public ConfigurationNodeCollection Configurations public ConfigurationNodeCollection Configurations
{ {
get get
{ {
ConfigurationNodeCollection tmp = new ConfigurationNodeCollection(); ConfigurationNodeCollection tmp = new ConfigurationNodeCollection();
tmp.AddRange(ConfigurationsTable); tmp.AddRange(ConfigurationsTable);
return tmp; return tmp;
} }
} }
/// <summary> /// <summary>
/// Gets the configurations table. /// Gets the configurations table.
/// </summary> /// </summary>
/// <value>The configurations table.</value> /// <value>The configurations table.</value>
public ConfigurationNodeCollection ConfigurationsTable public ConfigurationNodeCollection ConfigurationsTable
{ {
get get
{ {
return m_Configurations; return m_Configurations;
} }
} }
/// <summary> /// <summary>
/// Gets the database projects. /// Gets the database projects.
/// </summary> /// </summary>
@ -250,106 +250,106 @@ namespace Prebuild.Core.Nodes
return m_Solutions; return m_Solutions;
} }
} }
/// <summary> /// <summary>
/// Gets the projects. /// Gets the projects.
/// </summary> /// </summary>
/// <value>The projects.</value> /// <value>The projects.</value>
public ICollection<ProjectNode> Projects public ICollection<ProjectNode> Projects
{ {
get get
{ {
List<ProjectNode> tmp = new List<ProjectNode>(m_Projects.Values); List<ProjectNode> tmp = new List<ProjectNode>(m_Projects.Values);
tmp.Sort(); tmp.Sort();
return tmp; return tmp;
} }
} }
/// <summary> /// <summary>
/// Gets the projects table. /// Gets the projects table.
/// </summary> /// </summary>
/// <value>The projects table.</value> /// <value>The projects table.</value>
public Dictionary<string, ProjectNode> ProjectsTable public Dictionary<string, ProjectNode> ProjectsTable
{ {
get get
{ {
return m_Projects; return m_Projects;
} }
} }
/// <summary> /// <summary>
/// Gets the projects table. /// Gets the projects table.
/// </summary> /// </summary>
/// <value>The projects table.</value> /// <value>The projects table.</value>
public List<ProjectNode> ProjectsTableOrder public List<ProjectNode> ProjectsTableOrder
{ {
get get
{ {
return m_ProjectsOrder; return m_ProjectsOrder;
} }
} }
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// Parses the specified node. /// Parses the specified node.
/// </summary> /// </summary>
/// <param name="node">The node.</param> /// <param name="node">The node.</param>
public override void Parse(XmlNode node) public override void Parse(XmlNode node)
{ {
m_Name = Helper.AttributeValue(node, "name", m_Name); m_Name = Helper.AttributeValue(node, "name", m_Name);
m_ActiveConfig = Helper.AttributeValue(node, "activeConfig", m_ActiveConfig); m_ActiveConfig = Helper.AttributeValue(node, "activeConfig", m_ActiveConfig);
m_Path = Helper.AttributeValue(node, "path", m_Path); m_Path = Helper.AttributeValue(node, "path", m_Path);
m_Version = Helper.AttributeValue(node, "version", m_Version); m_Version = Helper.AttributeValue(node, "version", m_Version);
m_FullPath = m_Path; m_FullPath = m_Path;
try try
{ {
m_FullPath = Helper.ResolvePath(m_FullPath); m_FullPath = Helper.ResolvePath(m_FullPath);
} }
catch catch
{ {
throw new WarningException("Could not resolve solution path: {0}", m_Path); throw new WarningException("Could not resolve solution path: {0}", m_Path);
} }
Kernel.Instance.CurrentWorkingDirectory.Push(); Kernel.Instance.CurrentWorkingDirectory.Push();
try try
{ {
Helper.SetCurrentDir(m_FullPath); Helper.SetCurrentDir(m_FullPath);
if( node == null ) if( node == null )
{ {
throw new ArgumentNullException("node"); throw new ArgumentNullException("node");
} }
foreach(XmlNode child in node.ChildNodes) foreach(XmlNode child in node.ChildNodes)
{ {
IDataNode dataNode = Kernel.Instance.ParseNode(child, this); IDataNode dataNode = Kernel.Instance.ParseNode(child, this);
if(dataNode is OptionsNode) if(dataNode is OptionsNode)
{ {
m_Options = (OptionsNode)dataNode; m_Options = (OptionsNode)dataNode;
} }
else if(dataNode is FilesNode) else if(dataNode is FilesNode)
{ {
m_Files = (FilesNode)dataNode; m_Files = (FilesNode)dataNode;
} }
else if(dataNode is ConfigurationNode) else if(dataNode is ConfigurationNode)
{ {
ConfigurationNode configurationNode = (ConfigurationNode) dataNode; ConfigurationNode configurationNode = (ConfigurationNode) dataNode;
m_Configurations[configurationNode.NameAndPlatform] = configurationNode; m_Configurations[configurationNode.NameAndPlatform] = configurationNode;
// If the active configuration is null, then we populate it. // If the active configuration is null, then we populate it.
if (ActiveConfig == null) if (ActiveConfig == null)
{ {
ActiveConfig = configurationNode.Name; ActiveConfig = configurationNode.Name;
} }
} }
else if(dataNode is ProjectNode) else if(dataNode is ProjectNode)
{ {
m_Projects[((ProjectNode)dataNode).Name] = (ProjectNode) dataNode; m_Projects[((ProjectNode)dataNode).Name] = (ProjectNode) dataNode;
m_ProjectsOrder.Add((ProjectNode)dataNode); m_ProjectsOrder.Add((ProjectNode)dataNode);
} }
else if(dataNode is SolutionNode) else if(dataNode is SolutionNode)
{ {
m_Solutions[((SolutionNode)dataNode).Name] = (SolutionNode) dataNode; m_Solutions[((SolutionNode)dataNode).Name] = (SolutionNode) dataNode;
@ -369,14 +369,14 @@ namespace Prebuild.Core.Nodes
throw new WarningException("There can only be one Cleanup node."); throw new WarningException("There can only be one Cleanup node.");
m_Cleanup = (CleanupNode)dataNode; m_Cleanup = (CleanupNode)dataNode;
} }
} }
} }
finally finally
{ {
Kernel.Instance.CurrentWorkingDirectory.Pop(); Kernel.Instance.CurrentWorkingDirectory.Pop();
} }
} }
#endregion #endregion
} }
} }

224
Prebuild/src/Core/Parse/IfContext.cs
View File

@ -27,128 +27,128 @@ using System;
namespace Prebuild.Core.Parse namespace Prebuild.Core.Parse
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public enum IfState public enum IfState
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
None, None,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
If, If,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
ElseIf, ElseIf,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
Else Else
} }
/// <summary> /// <summary>
/// Summary description for IfContext. /// Summary description for IfContext.
/// </summary> /// </summary>
// Inspired by the equivalent WiX class (see www.sourceforge.net/projects/wix/) // Inspired by the equivalent WiX class (see www.sourceforge.net/projects/wix/)
public class IfContext public class IfContext
{ {
#region Properties #region Properties
bool m_Active; bool m_Active;
bool m_Keep; bool m_Keep;
bool m_EverKept; bool m_EverKept;
IfState m_State = IfState.None; IfState m_State = IfState.None;
#endregion #endregion
#region Constructors #region Constructors
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="IfContext"/> class. /// Initializes a new instance of the <see cref="IfContext"/> class.
/// </summary> /// </summary>
/// <param name="active">if set to <c>true</c> [active].</param> /// <param name="active">if set to <c>true</c> [active].</param>
/// <param name="keep">if set to <c>true</c> [keep].</param> /// <param name="keep">if set to <c>true</c> [keep].</param>
/// <param name="state">The state.</param> /// <param name="state">The state.</param>
public IfContext(bool active, bool keep, IfState state) public IfContext(bool active, bool keep, IfState state)
{ {
m_Active = active; m_Active = active;
m_Keep = keep; m_Keep = keep;
m_EverKept = keep; m_EverKept = keep;
m_State = state; m_State = state;
} }
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// Gets or sets a value indicating whether this <see cref="IfContext"/> is active. /// Gets or sets a value indicating whether this <see cref="IfContext"/> is active.
/// </summary> /// </summary>
/// <value><c>true</c> if active; otherwise, <c>false</c>.</value> /// <value><c>true</c> if active; otherwise, <c>false</c>.</value>
public bool Active public bool Active
{ {
get get
{ {
return m_Active; return m_Active;
} }
set set
{ {
m_Active = value; m_Active = value;
} }
} }
/// <summary> /// <summary>
/// Gets or sets a value indicating whether this <see cref="IfContext"/> is keep. /// Gets or sets a value indicating whether this <see cref="IfContext"/> is keep.
/// </summary> /// </summary>
/// <value><c>true</c> if keep; otherwise, <c>false</c>.</value> /// <value><c>true</c> if keep; otherwise, <c>false</c>.</value>
public bool Keep public bool Keep
{ {
get get
{ {
return m_Keep; return m_Keep;
} }
set set
{ {
m_Keep = value; m_Keep = value;
if(m_Keep) if(m_Keep)
{ {
m_EverKept = true; m_EverKept = true;
} }
} }
} }
/// <summary> /// <summary>
/// Gets a value indicating whether [ever kept]. /// Gets a value indicating whether [ever kept].
/// </summary> /// </summary>
/// <value><c>true</c> if [ever kept]; otherwise, <c>false</c>.</value> /// <value><c>true</c> if [ever kept]; otherwise, <c>false</c>.</value>
public bool EverKept public bool EverKept
{ {
get get
{ {
return m_EverKept; return m_EverKept;
} }
} }
/// <summary> /// <summary>
/// Gets or sets the state. /// Gets or sets the state.
/// </summary> /// </summary>
/// <value>The state.</value> /// <value>The state.</value>
public IfState State public IfState State
{ {
get get
{ {
return m_State; return m_State;
} }
set set
{ {
m_State = value; m_State = value;
} }
} }
#endregion #endregion
} }
} }

900
Prebuild/src/Core/Parse/Preprocessor.cs
View File

@ -31,336 +31,336 @@ using System.Xml;
namespace Prebuild.Core.Parse namespace Prebuild.Core.Parse
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public enum OperatorSymbol public enum OperatorSymbol
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
None, None,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
Equal, Equal,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
NotEqual, NotEqual,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
LessThan, LessThan,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
GreaterThan, GreaterThan,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
LessThanEqual, LessThanEqual,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
GreaterThanEqual GreaterThanEqual
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public class Preprocessor public class Preprocessor
{ {
#region Constants #region Constants
/// <summary> /// <summary>
/// Includes the regex to look for file tags in the <?include /// Includes the regex to look for file tags in the <?include
/// ?> processing instruction. /// ?> processing instruction.
/// </summary> /// </summary>
private static readonly Regex includeFileRegex = new Regex("file=\"(.+?)\""); private static readonly Regex includeFileRegex = new Regex("file=\"(.+?)\"");
#endregion #endregion
#region Fields #region Fields
readonly XmlDocument m_OutDoc = new XmlDocument(); readonly XmlDocument m_OutDoc = new XmlDocument();
readonly Stack<IfContext> m_IfStack = new Stack<IfContext>(); readonly Stack<IfContext> m_IfStack = new Stack<IfContext>();
readonly Dictionary<string, object> m_Variables = new Dictionary<string, object>(); readonly Dictionary<string, object> m_Variables = new Dictionary<string, object>();
#endregion #endregion
#region Constructors #region Constructors
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="Preprocessor"/> class. /// Initializes a new instance of the <see cref="Preprocessor"/> class.
/// </summary> /// </summary>
public Preprocessor() public Preprocessor()
{ {
RegisterVariable("OS", GetOS()); RegisterVariable("OS", GetOS());
RegisterVariable("RuntimeVersion", Environment.Version.Major); RegisterVariable("RuntimeVersion", Environment.Version.Major);
RegisterVariable("RuntimeMajor", Environment.Version.Major); RegisterVariable("RuntimeMajor", Environment.Version.Major);
RegisterVariable("RuntimeMinor", Environment.Version.Minor); RegisterVariable("RuntimeMinor", Environment.Version.Minor);
RegisterVariable("RuntimeRevision", Environment.Version.Revision); RegisterVariable("RuntimeRevision", Environment.Version.Revision);
} }
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// Gets the processed doc. /// Gets the processed doc.
/// </summary> /// </summary>
/// <value>The processed doc.</value> /// <value>The processed doc.</value>
public XmlDocument ProcessedDoc public XmlDocument ProcessedDoc
{ {
get get
{ {
return m_OutDoc; return m_OutDoc;
} }
} }
#endregion #endregion
#region Private Methods #region Private Methods
/// <summary> /// <summary>
/// Parts of this code were taken from NAnt and is subject to the GPL /// Parts of this code were taken from NAnt and is subject to the GPL
/// as per NAnt's license. Thanks to the NAnt guys for this little gem. /// as per NAnt's license. Thanks to the NAnt guys for this little gem.
/// </summary> /// </summary>
/// <returns></returns> /// <returns></returns>
public static string GetOS() public static string GetOS()
{ {
PlatformID platId = Environment.OSVersion.Platform; PlatformID platId = Environment.OSVersion.Platform;
if(platId == PlatformID.Win32NT || platId == PlatformID.Win32Windows) if(platId == PlatformID.Win32NT || platId == PlatformID.Win32Windows)
{ {
return "Win32"; return "Win32";
} }
if (File.Exists("/System/Library/Frameworks/Cocoa.framework/Cocoa")) if (File.Exists("/System/Library/Frameworks/Cocoa.framework/Cocoa"))
{ {
return "MACOSX"; return "MACOSX";
} }
/* /*
* .NET 1.x, under Mono, the UNIX code is 128. Under * .NET 1.x, under Mono, the UNIX code is 128. Under
* .NET 2.x, Mono or MS, the UNIX code is 4 * .NET 2.x, Mono or MS, the UNIX code is 4
*/ */
if(Environment.Version.Major == 1) if(Environment.Version.Major == 1)
{ {
if((int)platId == 128) if((int)platId == 128)
{ {
return "UNIX"; return "UNIX";
} }
} }
else if((int)platId == 4) else if((int)platId == 4)
{ {
return "UNIX"; return "UNIX";
} }
return "Unknown"; return "Unknown";
} }
private static bool CompareNum(OperatorSymbol oper, int val1, int val2) private static bool CompareNum(OperatorSymbol oper, int val1, int val2)
{ {
switch(oper) switch(oper)
{ {
case OperatorSymbol.Equal: case OperatorSymbol.Equal:
return (val1 == val2); return (val1 == val2);
case OperatorSymbol.NotEqual: case OperatorSymbol.NotEqual:
return (val1 != val2); return (val1 != val2);
case OperatorSymbol.LessThan: case OperatorSymbol.LessThan:
return (val1 < val2); return (val1 < val2);
case OperatorSymbol.LessThanEqual: case OperatorSymbol.LessThanEqual:
return (val1 <= val2); return (val1 <= val2);
case OperatorSymbol.GreaterThan: case OperatorSymbol.GreaterThan:
return (val1 > val2); return (val1 > val2);
case OperatorSymbol.GreaterThanEqual: case OperatorSymbol.GreaterThanEqual:
return (val1 >= val2); return (val1 >= val2);
} }
throw new WarningException("Unknown operator type"); throw new WarningException("Unknown operator type");
} }
private static bool CompareStr(OperatorSymbol oper, string val1, string val2) private static bool CompareStr(OperatorSymbol oper, string val1, string val2)
{ {
switch(oper) switch(oper)
{ {
case OperatorSymbol.Equal: case OperatorSymbol.Equal:
return (val1 == val2); return (val1 == val2);
case OperatorSymbol.NotEqual: case OperatorSymbol.NotEqual:
return (val1 != val2); return (val1 != val2);
case OperatorSymbol.LessThan: case OperatorSymbol.LessThan:
return (val1.CompareTo(val2) < 0); return (val1.CompareTo(val2) < 0);
case OperatorSymbol.LessThanEqual: case OperatorSymbol.LessThanEqual:
return (val1.CompareTo(val2) <= 0); return (val1.CompareTo(val2) <= 0);
case OperatorSymbol.GreaterThan: case OperatorSymbol.GreaterThan:
return (val1.CompareTo(val2) > 0); return (val1.CompareTo(val2) > 0);
case OperatorSymbol.GreaterThanEqual: case OperatorSymbol.GreaterThanEqual:
return (val1.CompareTo(val2) >= 0); return (val1.CompareTo(val2) >= 0);
} }
throw new WarningException("Unknown operator type"); throw new WarningException("Unknown operator type");
} }
private static char NextChar(int idx, string str) private static char NextChar(int idx, string str)
{ {
if((idx + 1) >= str.Length) if((idx + 1) >= str.Length)
{ {
return Char.MaxValue; return Char.MaxValue;
} }
return str[idx + 1]; return str[idx + 1];
} }
// Very very simple expression parser. Can only match expressions of the form // Very very simple expression parser. Can only match expressions of the form
// <var> <op> <value>: // <var> <op> <value>:
// OS = Windows // OS = Windows
// OS != Linux // OS != Linux
// RuntimeMinor > 0 // RuntimeMinor > 0
private bool ParseExpression(string exp) private bool ParseExpression(string exp)
{ {
if(exp == null) if(exp == null)
{ {
throw new ArgumentException("Invalid expression, cannot be null"); throw new ArgumentException("Invalid expression, cannot be null");
} }
exp = exp.Trim(); exp = exp.Trim();
if(exp.Length < 1) if(exp.Length < 1)
{ {
throw new ArgumentException("Invalid expression, cannot be 0 length"); throw new ArgumentException("Invalid expression, cannot be 0 length");
} }
string id = ""; string id = "";
string str = ""; string str = "";
OperatorSymbol oper = OperatorSymbol.None; OperatorSymbol oper = OperatorSymbol.None;
bool inStr = false; bool inStr = false;
for(int i = 0; i < exp.Length; i++) for(int i = 0; i < exp.Length; i++)
{ {
char c = exp[i]; char c = exp[i];
if(Char.IsWhiteSpace(c)) if(Char.IsWhiteSpace(c))
{ {
continue; continue;
} }
if(Char.IsLetterOrDigit(c) || c == '_') if(Char.IsLetterOrDigit(c) || c == '_')
{ {
if(inStr) if(inStr)
{ {
str += c; str += c;
} }
else else
{ {
id += c; id += c;
} }
} }
else if(c == '\"') else if(c == '\"')
{ {
inStr = !inStr; inStr = !inStr;
if(inStr) if(inStr)
{ {
str = ""; str = "";
} }
} }
else else
{ {
if(inStr) if(inStr)
{ {
str += c; str += c;
} }
else else
{ {
switch(c) switch(c)
{ {
case '=': case '=':
oper = OperatorSymbol.Equal; oper = OperatorSymbol.Equal;
break; break;
case '!': case '!':
if(NextChar(i, exp) == '=') if(NextChar(i, exp) == '=')
{ {
oper = OperatorSymbol.NotEqual; oper = OperatorSymbol.NotEqual;
} }
break; break;
case '<': case '<':
if(NextChar(i, exp) == '=') if(NextChar(i, exp) == '=')
{ {
oper = OperatorSymbol.LessThanEqual; oper = OperatorSymbol.LessThanEqual;
} }
else else
{ {
oper = OperatorSymbol.LessThan; oper = OperatorSymbol.LessThan;
} }
break; break;
case '>': case '>':
if(NextChar(i, exp) == '=') if(NextChar(i, exp) == '=')
{ {
oper = OperatorSymbol.GreaterThanEqual; oper = OperatorSymbol.GreaterThanEqual;
} }
else else
{ {
oper = OperatorSymbol.GreaterThan; oper = OperatorSymbol.GreaterThan;
} }
break; break;
} }
} }
} }
} }
if(inStr) if(inStr)
{ {
throw new WarningException("Expected end of string in expression"); throw new WarningException("Expected end of string in expression");
} }
if(oper == OperatorSymbol.None) if(oper == OperatorSymbol.None)
{ {
throw new WarningException("Expected operator in expression"); throw new WarningException("Expected operator in expression");
} }
if(id.Length < 1) if(id.Length < 1)
{ {
throw new WarningException("Expected identifier in expression"); throw new WarningException("Expected identifier in expression");
} }
if(str.Length < 1) if(str.Length < 1)
{ {
throw new WarningException("Expected value in expression"); throw new WarningException("Expected value in expression");
} }
bool ret; bool ret;
try try
{ {
object val = m_Variables[id.ToLower()]; object val = m_Variables[id.ToLower()];
if(val == null) if(val == null)
{ {
throw new WarningException("Unknown identifier '{0}'", id); throw new WarningException("Unknown identifier '{0}'", id);
} }
Type t = val.GetType(); Type t = val.GetType();
if(t.IsAssignableFrom(typeof(int))) if(t.IsAssignableFrom(typeof(int)))
{ {
int numVal = (int)val; int numVal = (int)val;
int numVal2 = Int32.Parse(str); int numVal2 = Int32.Parse(str);
ret = CompareNum(oper, numVal, numVal2); ret = CompareNum(oper, numVal, numVal2);
} }
else else
{ {
string strVal = val.ToString(); string strVal = val.ToString();
string strVal2 = str; string strVal2 = str;
ret = CompareStr(oper, strVal, strVal2); ret = CompareStr(oper, strVal, strVal2);
} }
} }
catch(ArgumentException ex) catch(ArgumentException ex)
{ {
ex.ToString(); ex.ToString();
throw new WarningException("Invalid value type for system variable '{0}', expected int", id); throw new WarningException("Invalid value type for system variable '{0}', expected int", id);
} }
return ret; return ret;
} }
/// <summary> /// <summary>
/// Taken from current Prebuild included in OpenSim 0.7.x /// Taken from current Prebuild included in OpenSim 0.7.x
@ -426,85 +426,85 @@ namespace Prebuild.Core.Parse
} }
} }
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
/// <param name="name"></param> /// <param name="name"></param>
/// <param name="variableValue"></param> /// <param name="variableValue"></param>
public void RegisterVariable(string name, object variableValue) public void RegisterVariable(string name, object variableValue)
{ {
if(name == null || variableValue == null) if(name == null || variableValue == null)
{ {
return; return;
} }
m_Variables[name.ToLower()] = variableValue; m_Variables[name.ToLower()] = variableValue;
} }
/// <summary> /// <summary>
/// Performs validation on the xml source as well as evaluates conditional and flow expresions /// Performs validation on the xml source as well as evaluates conditional and flow expresions
/// </summary> /// </summary>
/// <exception cref="ArgumentException">For invalid use of conditional expressions or for invalid XML syntax. If a XmlValidatingReader is passed, then will also throw exceptions for non-schema-conforming xml</exception> /// <exception cref="ArgumentException">For invalid use of conditional expressions or for invalid XML syntax. If a XmlValidatingReader is passed, then will also throw exceptions for non-schema-conforming xml</exception>
/// <param name="initialReader"></param> /// <param name="initialReader"></param>
/// <returns>the output xml </returns> /// <returns>the output xml </returns>
public string Process(XmlReader initialReader) public string Process(XmlReader initialReader)
{ {
if(initialReader == null) if(initialReader == null)
{ {
throw new ArgumentException("Invalid XML reader to pre-process"); throw new ArgumentException("Invalid XML reader to pre-process");
} }
IfContext context = new IfContext(true, true, IfState.None); IfContext context = new IfContext(true, true, IfState.None);
StringWriter xmlText = new StringWriter(); StringWriter xmlText = new StringWriter();
XmlTextWriter writer = new XmlTextWriter(xmlText); XmlTextWriter writer = new XmlTextWriter(xmlText);
writer.Formatting = Formatting.Indented; writer.Formatting = Formatting.Indented;
// Create a queue of XML readers and add the initial // Create a queue of XML readers and add the initial
// reader to it. Then we process until we run out of // reader to it. Then we process until we run out of
// readers which lets the <?include?> operation add more // readers which lets the <?include?> operation add more
// readers to generate a multi-file parser and not require // readers to generate a multi-file parser and not require
// XML fragments that a recursive version would use. // XML fragments that a recursive version would use.
Stack<XmlReader> readerStack = new Stack<XmlReader>(); Stack<XmlReader> readerStack = new Stack<XmlReader>();
readerStack.Push(initialReader); readerStack.Push(initialReader);
while(readerStack.Count > 0) while(readerStack.Count > 0)
{ {
// Pop off the next reader. // Pop off the next reader.
XmlReader reader = readerStack.Pop(); XmlReader reader = readerStack.Pop();
// Process through this XML reader until it is // Process through this XML reader until it is
// completed (or it is replaced by the include // completed (or it is replaced by the include
// operation). // operation).
while(reader.Read()) while(reader.Read())
{ {
// The prebuild file has a series of processing // The prebuild file has a series of processing
// instructions which allow for specific // instructions which allow for specific
// inclusions based on operating system or to // inclusions based on operating system or to
// include additional files. // include additional files.
if(reader.NodeType == XmlNodeType.ProcessingInstruction) if(reader.NodeType == XmlNodeType.ProcessingInstruction)
{ {
bool ignore = false; bool ignore = false;
switch(reader.LocalName) switch(reader.LocalName)
{ {
case "include": case "include":
// use regular expressions to parse out the attributes. // use regular expressions to parse out the attributes.
MatchCollection matches = includeFileRegex.Matches(reader.Value); MatchCollection matches = includeFileRegex.Matches(reader.Value);
// make sure there is only one file attribute. // make sure there is only one file attribute.
if(matches.Count > 1) if(matches.Count > 1)
{ {
throw new WarningException("An <?include ?> node was found, but it specified more than one file."); throw new WarningException("An <?include ?> node was found, but it specified more than one file.");
} }
if(matches.Count == 0) if(matches.Count == 0)
{ {
throw new WarningException("An <?include ?> node was found, but it did not specify the file attribute."); throw new WarningException("An <?include ?> node was found, but it did not specify the file attribute.");
} }
// ***** Adding for wildcard handling // ***** Adding for wildcard handling
// Push current reader back onto the stack. // Push current reader back onto the stack.
@ -537,116 +537,116 @@ namespace Prebuild.Core.Parse
ignore = true; ignore = true;
break; break;
case "if": case "if":
m_IfStack.Push(context); m_IfStack.Push(context);
context = new IfContext(context.Keep & context.Active, ParseExpression(reader.Value), IfState.If); context = new IfContext(context.Keep & context.Active, ParseExpression(reader.Value), IfState.If);
ignore = true; ignore = true;
break; break;
case "elseif": case "elseif":
if(m_IfStack.Count == 0) if(m_IfStack.Count == 0)
{ {
throw new WarningException("Unexpected 'elseif' outside of 'if'"); throw new WarningException("Unexpected 'elseif' outside of 'if'");
} }
if(context.State != IfState.If && context.State != IfState.ElseIf) if(context.State != IfState.If && context.State != IfState.ElseIf)
{ {
throw new WarningException("Unexpected 'elseif' outside of 'if'"); throw new WarningException("Unexpected 'elseif' outside of 'if'");
} }
context.State = IfState.ElseIf; context.State = IfState.ElseIf;
if(!context.EverKept) if(!context.EverKept)
{ {
context.Keep = ParseExpression(reader.Value); context.Keep = ParseExpression(reader.Value);
} }
else else
{ {
context.Keep = false; context.Keep = false;
} }
ignore = true; ignore = true;
break; break;
case "else": case "else":
if(m_IfStack.Count == 0) if(m_IfStack.Count == 0)
{ {
throw new WarningException("Unexpected 'else' outside of 'if'"); throw new WarningException("Unexpected 'else' outside of 'if'");
} }
if(context.State != IfState.If && context.State != IfState.ElseIf) if(context.State != IfState.If && context.State != IfState.ElseIf)
{ {
throw new WarningException("Unexpected 'else' outside of 'if'"); throw new WarningException("Unexpected 'else' outside of 'if'");
} }
context.State = IfState.Else; context.State = IfState.Else;
context.Keep = !context.EverKept; context.Keep = !context.EverKept;
ignore = true; ignore = true;
break; break;
case "endif": case "endif":
if(m_IfStack.Count == 0) if(m_IfStack.Count == 0)
{ {
throw new WarningException("Unexpected 'endif' outside of 'if'"); throw new WarningException("Unexpected 'endif' outside of 'if'");
} }
context = m_IfStack.Pop(); context = m_IfStack.Pop();
ignore = true; ignore = true;
break; break;
} }
if(ignore) if(ignore)
{ {
continue; continue;
} }
}//end pre-proc instruction }//end pre-proc instruction
if(!context.Active || !context.Keep) if(!context.Active || !context.Keep)
{ {
continue; continue;
} }
switch(reader.NodeType) switch(reader.NodeType)
{ {
case XmlNodeType.Element: case XmlNodeType.Element:
bool empty = reader.IsEmptyElement; bool empty = reader.IsEmptyElement;
writer.WriteStartElement(reader.Name); writer.WriteStartElement(reader.Name);
while (reader.MoveToNextAttribute()) while (reader.MoveToNextAttribute())
{ {
writer.WriteAttributeString(reader.Name, reader.Value); writer.WriteAttributeString(reader.Name, reader.Value);
} }
if(empty) if(empty)
{ {
writer.WriteEndElement(); writer.WriteEndElement();
} }
break; break;
case XmlNodeType.EndElement: case XmlNodeType.EndElement:
writer.WriteEndElement(); writer.WriteEndElement();
break; break;
case XmlNodeType.Text: case XmlNodeType.Text:
writer.WriteString(reader.Value); writer.WriteString(reader.Value);
break; break;
case XmlNodeType.CDATA: case XmlNodeType.CDATA:
writer.WriteCData(reader.Value); writer.WriteCData(reader.Value);
break; break;
default: default:
break; break;
} }
} }
if(m_IfStack.Count != 0) if(m_IfStack.Count != 0)
{ {
throw new WarningException("Mismatched 'if', 'endif' pair"); throw new WarningException("Mismatched 'if', 'endif' pair");
} }
} }
return xmlText.ToString(); return xmlText.ToString();
} }
#endregion #endregion
} }
} }

84
Prebuild/src/Core/Targets/DebugTarget.cs
View File

@ -41,62 +41,62 @@ using Prebuild.Core.Nodes;
#if (DEBUG && _DEBUG_TARGET) #if (DEBUG && _DEBUG_TARGET)
namespace Prebuild.Core.Targets namespace Prebuild.Core.Targets
{ {
[Target("debug")] [Target("debug")]
public class DebugTarget : ITarget public class DebugTarget : ITarget
{ {
#region Fields #region Fields
private Kernel m_Kernel = null; private Kernel m_Kernel = null;
#endregion #endregion
#region ITarget Members #region ITarget Members
public void Write() public void Write()
{ {
foreach(SolutionNode s in m_Kernel.Solutions) foreach(SolutionNode s in m_Kernel.Solutions)
{ {
Console.WriteLine("Solution [ {0}, {1} ]", s.Name, s.Path); Console.WriteLine("Solution [ {0}, {1} ]", s.Name, s.Path);
foreach(string file in s.Files) foreach(string file in s.Files)
{ {
Console.WriteLine("\tFile [ {0} ]", file); Console.WriteLine("\tFile [ {0} ]", file);
} }
foreach(ProjectNode proj in s.Projects) foreach(ProjectNode proj in s.Projects)
{ {
Console.WriteLine("\tProject [ {0}, {1}. {2} ]", proj.Name, proj.Path, proj.Language); Console.WriteLine("\tProject [ {0}, {1}. {2} ]", proj.Name, proj.Path, proj.Language);
foreach(string file in proj.Files) foreach(string file in proj.Files)
Console.WriteLine("\t\tFile [ {0} ]", file); Console.WriteLine("\t\tFile [ {0} ]", file);
} }
} }
} }
public void Clean() public void Clean()
{ {
Console.WriteLine("Not implemented"); Console.WriteLine("Not implemented");
} }
public string Name public string Name
{ {
get get
{ {
return "debug"; return "debug";
} }
} }
public Kernel Kernel public Kernel Kernel
{ {
get get
{ {
return m_Kernel; return m_Kernel;
} }
set set
{ {
m_Kernel = value; m_Kernel = value;
} }
} }
#endregion #endregion
} }
} }
#endif #endif

808
Prebuild/src/Core/Targets/MonoDevelopTarget.cs
View File

@ -35,481 +35,481 @@ using Prebuild.Core.Utilities;
namespace Prebuild.Core.Targets namespace Prebuild.Core.Targets
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[Target("monodev")] [Target("monodev")]
public class MonoDevelopTarget : ITarget public class MonoDevelopTarget : ITarget
{ {
#region Fields #region Fields
private Kernel m_Kernel; private Kernel m_Kernel;
#endregion #endregion
#region Private Methods #region Private Methods
private static string PrependPath(string path) private static string PrependPath(string path)
{ {
string tmpPath = Helper.NormalizePath(path, '/'); string tmpPath = Helper.NormalizePath(path, '/');
Regex regex = new Regex(@"(\w):/(\w+)"); Regex regex = new Regex(@"(\w):/(\w+)");
Match match = regex.Match(tmpPath); Match match = regex.Match(tmpPath);
if(match.Success || tmpPath[0] == '.' || tmpPath[0] == '/') if(match.Success || tmpPath[0] == '.' || tmpPath[0] == '/')
{ {
tmpPath = Helper.NormalizePath(tmpPath); tmpPath = Helper.NormalizePath(tmpPath);
} }
else else
{ {
tmpPath = Helper.NormalizePath("./" + tmpPath); tmpPath = Helper.NormalizePath("./" + tmpPath);
} }
return tmpPath; return tmpPath;
} }
private static string BuildReference(SolutionNode solution, ReferenceNode refr) private static string BuildReference(SolutionNode solution, ReferenceNode refr)
{ {
string ret = "<ProjectReference type=\""; string ret = "<ProjectReference type=\"";
if(solution.ProjectsTable.ContainsKey(refr.Name)) if(solution.ProjectsTable.ContainsKey(refr.Name))
{ {
ret += "Project\""; ret += "Project\"";
ret += " localcopy=\"" + refr.LocalCopy.ToString() + "\" refto=\"" + refr.Name + "\" />"; ret += " localcopy=\"" + refr.LocalCopy.ToString() + "\" refto=\"" + refr.Name + "\" />";
} }
else else
{ {
ProjectNode project = (ProjectNode)refr.Parent; ProjectNode project = (ProjectNode)refr.Parent;
string fileRef = FindFileReference(refr.Name, project); string fileRef = FindFileReference(refr.Name, project);
if(refr.Path != null || fileRef != null) if(refr.Path != null || fileRef != null)
{ {
ret += "Assembly\" refto=\""; ret += "Assembly\" refto=\"";
string finalPath = (refr.Path != null) ? Helper.MakeFilePath(refr.Path, refr.Name, "dll") : fileRef; string finalPath = (refr.Path != null) ? Helper.MakeFilePath(refr.Path, refr.Name, "dll") : fileRef;
ret += finalPath; ret += finalPath;
ret += "\" localcopy=\"" + refr.LocalCopy.ToString() + "\" />"; ret += "\" localcopy=\"" + refr.LocalCopy.ToString() + "\" />";
return ret; return ret;
} }
ret += "Gac\""; ret += "Gac\"";
ret += " localcopy=\"" + refr.LocalCopy.ToString() + "\""; ret += " localcopy=\"" + refr.LocalCopy.ToString() + "\"";
ret += " refto=\""; ret += " refto=\"";
try try
{ {
/* /*
Day changed to 28 Mar 2007 Day changed to 28 Mar 2007
... ...
08:09 < cj> is there anything that replaces Assembly.LoadFromPartialName() ? 08:09 < cj> is there anything that replaces Assembly.LoadFromPartialName() ?
08:09 < jonp> no 08:09 < jonp> no
08:10 < jonp> in their infinite wisdom [sic], microsoft decided that the 08:10 < jonp> in their infinite wisdom [sic], microsoft decided that the
ability to load any assembly version by-name was an inherently ability to load any assembly version by-name was an inherently
bad idea bad idea
08:11 < cj> I'm thinking of a bunch of four-letter words right now... 08:11 < cj> I'm thinking of a bunch of four-letter words right now...
08:11 < cj> security through making it difficult for the developer!!! 08:11 < cj> security through making it difficult for the developer!!!
08:12 < jonp> just use the Obsolete API 08:12 < jonp> just use the Obsolete API
08:12 < jonp> it should still work 08:12 < jonp> it should still work
08:12 < cj> alrighty. 08:12 < cj> alrighty.
08:12 < jonp> you just get warnings when using it 08:12 < jonp> you just get warnings when using it
*/ */
Assembly assem = Assembly.LoadWithPartialName(refr.Name); Assembly assem = Assembly.LoadWithPartialName(refr.Name);
ret += assem.FullName; ret += assem.FullName;
//ret += refr.Name; //ret += refr.Name;
} }
catch (System.NullReferenceException e) catch (System.NullReferenceException e)
{ {
e.ToString(); e.ToString();
ret += refr.Name; ret += refr.Name;
} }
ret += "\" />"; ret += "\" />";
} }
return ret; return ret;
} }
private static string FindFileReference(string refName, ProjectNode project) private static string FindFileReference(string refName, ProjectNode project)
{ {
foreach(ReferencePathNode refPath in project.ReferencePaths) foreach(ReferencePathNode refPath in project.ReferencePaths)
{ {
string fullPath = Helper.MakeFilePath(refPath.Path, refName, "dll"); string fullPath = Helper.MakeFilePath(refPath.Path, refName, "dll");
if(File.Exists(fullPath)) if(File.Exists(fullPath))
{ {
return fullPath; return fullPath;
} }
} }
return null; return null;
} }
/// <summary> /// <summary>
/// Gets the XML doc file. /// Gets the XML doc file.
/// </summary> /// </summary>
/// <param name="project">The project.</param> /// <param name="project">The project.</param>
/// <param name="conf">The conf.</param> /// <param name="conf">The conf.</param>
/// <returns></returns> /// <returns></returns>
public static string GenerateXmlDocFile(ProjectNode project, ConfigurationNode conf) public static string GenerateXmlDocFile(ProjectNode project, ConfigurationNode conf)
{ {
if( conf == null ) if( conf == null )
{ {
throw new ArgumentNullException("conf"); throw new ArgumentNullException("conf");
} }
if( project == null ) if( project == null )
{ {
throw new ArgumentNullException("project"); throw new ArgumentNullException("project");
} }
string docFile = (string)conf.Options["XmlDocFile"]; string docFile = (string)conf.Options["XmlDocFile"];
if(docFile != null && docFile.Length == 0)//default to assembly name if not specified if(docFile != null && docFile.Length == 0)//default to assembly name if not specified
{ {
return "False"; return "False";
} }
return "True"; return "True";
} }
private void WriteProject(SolutionNode solution, ProjectNode project) private void WriteProject(SolutionNode solution, ProjectNode project)
{ {
string csComp = "Mcs"; string csComp = "Mcs";
string netRuntime = "Mono"; string netRuntime = "Mono";
if(project.Runtime == ClrRuntime.Microsoft) if(project.Runtime == ClrRuntime.Microsoft)
{ {
csComp = "Csc"; csComp = "Csc";
netRuntime = "MsNet"; netRuntime = "MsNet";
} }
string projFile = Helper.MakeFilePath(project.FullPath, project.Name, "mdp"); string projFile = Helper.MakeFilePath(project.FullPath, project.Name, "mdp");
StreamWriter ss = new StreamWriter(projFile); StreamWriter ss = new StreamWriter(projFile);
m_Kernel.CurrentWorkingDirectory.Push(); m_Kernel.CurrentWorkingDirectory.Push();
Helper.SetCurrentDir(Path.GetDirectoryName(projFile)); Helper.SetCurrentDir(Path.GetDirectoryName(projFile));
using(ss) using(ss)
{ {
ss.WriteLine( ss.WriteLine(
"<Project name=\"{0}\" description=\"\" standardNamespace=\"{1}\" newfilesearch=\"None\" enableviewstate=\"True\" fileversion=\"2.0\" language=\"C#\" clr-version=\"Net_2_0\" ctype=\"DotNetProject\">", "<Project name=\"{0}\" description=\"\" standardNamespace=\"{1}\" newfilesearch=\"None\" enableviewstate=\"True\" fileversion=\"2.0\" language=\"C#\" clr-version=\"Net_2_0\" ctype=\"DotNetProject\">",
project.Name, project.Name,
project.RootNamespace project.RootNamespace
); );
int count = 0; int count = 0;
ss.WriteLine(" <Configurations active=\"{0}\">", solution.ActiveConfig); ss.WriteLine(" <Configurations active=\"{0}\">", solution.ActiveConfig);
foreach(ConfigurationNode conf in project.Configurations) foreach(ConfigurationNode conf in project.Configurations)
{ {
ss.WriteLine(" <Configuration name=\"{0}\" ctype=\"DotNetProjectConfiguration\">", conf.Name); ss.WriteLine(" <Configuration name=\"{0}\" ctype=\"DotNetProjectConfiguration\">", conf.Name);
ss.Write(" <Output"); ss.Write(" <Output");
ss.Write(" directory=\"{0}\"", Helper.EndPath(Helper.NormalizePath(".\\" + conf.Options["OutputPath"].ToString()))); ss.Write(" directory=\"{0}\"", Helper.EndPath(Helper.NormalizePath(".\\" + conf.Options["OutputPath"].ToString())));
ss.Write(" assembly=\"{0}\"", project.AssemblyName); ss.Write(" assembly=\"{0}\"", project.AssemblyName);
ss.Write(" executeScript=\"{0}\"", conf.Options["RunScript"]); ss.Write(" executeScript=\"{0}\"", conf.Options["RunScript"]);
//ss.Write(" executeBeforeBuild=\"{0}\"", conf.Options["PreBuildEvent"]); //ss.Write(" executeBeforeBuild=\"{0}\"", conf.Options["PreBuildEvent"]);
//ss.Write(" executeAfterBuild=\"{0}\"", conf.Options["PostBuildEvent"]); //ss.Write(" executeAfterBuild=\"{0}\"", conf.Options["PostBuildEvent"]);
if (conf.Options["PreBuildEvent"] != null && conf.Options["PreBuildEvent"].ToString().Length != 0) if (conf.Options["PreBuildEvent"] != null && conf.Options["PreBuildEvent"].ToString().Length != 0)
{ {
ss.Write(" executeBeforeBuild=\"{0}\"", Helper.NormalizePath(conf.Options["PreBuildEvent"].ToString())); ss.Write(" executeBeforeBuild=\"{0}\"", Helper.NormalizePath(conf.Options["PreBuildEvent"].ToString()));
} }
else else
{ {
ss.Write(" executeBeforeBuild=\"{0}\"", conf.Options["PreBuildEvent"]); ss.Write(" executeBeforeBuild=\"{0}\"", conf.Options["PreBuildEvent"]);
} }
if (conf.Options["PostBuildEvent"] != null && conf.Options["PostBuildEvent"].ToString().Length != 0) if (conf.Options["PostBuildEvent"] != null && conf.Options["PostBuildEvent"].ToString().Length != 0)
{ {
ss.Write(" executeAfterBuild=\"{0}\"", Helper.NormalizePath(conf.Options["PostBuildEvent"].ToString())); ss.Write(" executeAfterBuild=\"{0}\"", Helper.NormalizePath(conf.Options["PostBuildEvent"].ToString()));
} }
else else
{ {
ss.Write(" executeAfterBuild=\"{0}\"", conf.Options["PostBuildEvent"]); ss.Write(" executeAfterBuild=\"{0}\"", conf.Options["PostBuildEvent"]);
} }
ss.Write(" executeBeforeBuildArguments=\"{0}\"", conf.Options["PreBuildEventArgs"]); ss.Write(" executeBeforeBuildArguments=\"{0}\"", conf.Options["PreBuildEventArgs"]);
ss.Write(" executeAfterBuildArguments=\"{0}\"", conf.Options["PreBuildEventArgs"]); ss.Write(" executeAfterBuildArguments=\"{0}\"", conf.Options["PreBuildEventArgs"]);
ss.WriteLine(" />"); ss.WriteLine(" />");
ss.Write(" <Build"); ss.Write(" <Build");
ss.Write(" debugmode=\"True\""); ss.Write(" debugmode=\"True\"");
if (project.Type == ProjectType.WinExe) if (project.Type == ProjectType.WinExe)
{ {
ss.Write(" target=\"{0}\"", ProjectType.Exe.ToString()); ss.Write(" target=\"{0}\"", ProjectType.Exe.ToString());
} }
else else
{ {
ss.Write(" target=\"{0}\"", project.Type); ss.Write(" target=\"{0}\"", project.Type);
} }
ss.WriteLine(" />"); ss.WriteLine(" />");
ss.Write(" <Execution"); ss.Write(" <Execution");
ss.Write(" runwithwarnings=\"{0}\"", !conf.Options.WarningsAsErrors); ss.Write(" runwithwarnings=\"{0}\"", !conf.Options.WarningsAsErrors);
ss.Write(" consolepause=\"True\""); ss.Write(" consolepause=\"True\"");
ss.Write(" runtime=\"{0}\"", netRuntime); ss.Write(" runtime=\"{0}\"", netRuntime);
ss.Write(" clr-version=\"Net_2_0\""); ss.Write(" clr-version=\"Net_2_0\"");
ss.WriteLine(" />"); ss.WriteLine(" />");
ss.Write(" <CodeGeneration"); ss.Write(" <CodeGeneration");
ss.Write(" compiler=\"{0}\"", csComp); ss.Write(" compiler=\"{0}\"", csComp);
ss.Write(" warninglevel=\"{0}\"", conf.Options["WarningLevel"]); ss.Write(" warninglevel=\"{0}\"", conf.Options["WarningLevel"]);
ss.Write(" nowarn=\"{0}\"", conf.Options["SuppressWarnings"]); ss.Write(" nowarn=\"{0}\"", conf.Options["SuppressWarnings"]);
ss.Write(" includedebuginformation=\"{0}\"", conf.Options["DebugInformation"]); ss.Write(" includedebuginformation=\"{0}\"", conf.Options["DebugInformation"]);
ss.Write(" optimize=\"{0}\"", conf.Options["OptimizeCode"]); ss.Write(" optimize=\"{0}\"", conf.Options["OptimizeCode"]);
ss.Write(" unsafecodeallowed=\"{0}\"", conf.Options["AllowUnsafe"]); ss.Write(" unsafecodeallowed=\"{0}\"", conf.Options["AllowUnsafe"]);
ss.Write(" generateoverflowchecks=\"{0}\"", conf.Options["CheckUnderflowOverflow"]); ss.Write(" generateoverflowchecks=\"{0}\"", conf.Options["CheckUnderflowOverflow"]);
ss.Write(" mainclass=\"{0}\"", project.StartupObject); ss.Write(" mainclass=\"{0}\"", project.StartupObject);
ss.Write(" target=\"{0}\"", project.Type); ss.Write(" target=\"{0}\"", project.Type);
ss.Write(" definesymbols=\"{0}\"", conf.Options["CompilerDefines"]); ss.Write(" definesymbols=\"{0}\"", conf.Options["CompilerDefines"]);
ss.Write(" generatexmldocumentation=\"{0}\"", GenerateXmlDocFile(project, conf)); ss.Write(" generatexmldocumentation=\"{0}\"", GenerateXmlDocFile(project, conf));
ss.Write(" win32Icon=\"{0}\"", project.AppIcon); ss.Write(" win32Icon=\"{0}\"", project.AppIcon);
ss.Write(" ctype=\"CSharpCompilerParameters\""); ss.Write(" ctype=\"CSharpCompilerParameters\"");
ss.WriteLine(" />"); ss.WriteLine(" />");
ss.WriteLine(" </Configuration>"); ss.WriteLine(" </Configuration>");
count++; count++;
} }
ss.WriteLine(" </Configurations>"); ss.WriteLine(" </Configurations>");
ss.Write(" <DeploymentInformation"); ss.Write(" <DeploymentInformation");
ss.Write(" target=\"\""); ss.Write(" target=\"\"");
ss.Write(" script=\"\""); ss.Write(" script=\"\"");
ss.Write(" strategy=\"File\""); ss.Write(" strategy=\"File\"");
ss.WriteLine(">"); ss.WriteLine(">");
ss.WriteLine(" <excludeFiles />"); ss.WriteLine(" <excludeFiles />");
ss.WriteLine(" </DeploymentInformation>"); ss.WriteLine(" </DeploymentInformation>");
ss.WriteLine(" <Contents>"); ss.WriteLine(" <Contents>");
foreach(string file in project.Files) foreach(string file in project.Files)
{ {
string buildAction; string buildAction;
string dependson = ""; string dependson = "";
string resource_id = ""; string resource_id = "";
string copyToOutput = ""; string copyToOutput = "";
switch(project.Files.GetBuildAction(file)) switch(project.Files.GetBuildAction(file))
{ {
case BuildAction.None: case BuildAction.None:
buildAction = "Nothing"; buildAction = "Nothing";
break; break;
case BuildAction.Content: case BuildAction.Content:
buildAction = "Exclude"; buildAction = "Exclude";
break; break;
case BuildAction.EmbeddedResource: case BuildAction.EmbeddedResource:
buildAction = "EmbedAsResource"; buildAction = "EmbedAsResource";
break; break;
default: default:
buildAction = "Compile"; buildAction = "Compile";
break; break;
} }
if (project.Files.GetCopyToOutput(file) != CopyToOutput.Never) if (project.Files.GetCopyToOutput(file) != CopyToOutput.Never)
buildAction = "FileCopy"; buildAction = "FileCopy";
// Sort of a hack, we try and resolve the path and make it relative, if we can. // Sort of a hack, we try and resolve the path and make it relative, if we can.
string extension = Path.GetExtension(file); string extension = Path.GetExtension(file);
string designer_format = string.Format(".Designer{0}", extension); string designer_format = string.Format(".Designer{0}", extension);
if (file.EndsWith(designer_format)) if (file.EndsWith(designer_format))
{ {
string basename = file.Substring(0, file.LastIndexOf(designer_format)); string basename = file.Substring(0, file.LastIndexOf(designer_format));
string[] extensions = new string[] { ".cs", ".resx", ".settings" }; string[] extensions = new string[] { ".cs", ".resx", ".settings" };
foreach(string ext in extensions) foreach(string ext in extensions)
{ {
if (project.Files.Contains(basename + ext)) if (project.Files.Contains(basename + ext))
{ {
dependson = string.Format(" dependson=\"{0}{1}\"", basename, ext); dependson = string.Format(" dependson=\"{0}{1}\"", basename, ext);
break; break;
} }
} }
} }
if (extension == ".resx") if (extension == ".resx")
{ {
buildAction = "EmbedAsResource"; buildAction = "EmbedAsResource";
string basename = file.Substring(0, file.LastIndexOf(".resx")); string basename = file.Substring(0, file.LastIndexOf(".resx"));
// Visual Studio type resx + form dependency // Visual Studio type resx + form dependency
if (project.Files.Contains(basename + ".cs")) if (project.Files.Contains(basename + ".cs"))
{ {
dependson = string.Format(" dependson=\"{0}{1}\"", basename, ".cs"); dependson = string.Format(" dependson=\"{0}{1}\"", basename, ".cs");
} }
// We need to specify a resources file name to avoid MissingManifestResourceExceptions // We need to specify a resources file name to avoid MissingManifestResourceExceptions
// in libraries that are built. // in libraries that are built.
resource_id = string.Format(" resource_id=\"{0}.{1}.resources\"", resource_id = string.Format(" resource_id=\"{0}.{1}.resources\"",
project.AssemblyName, basename.Replace("/", ".")); project.AssemblyName, basename.Replace("/", "."));
} }
switch(project.Files.GetCopyToOutput(file)) switch(project.Files.GetCopyToOutput(file))
{ {
case CopyToOutput.Always: case CopyToOutput.Always:
copyToOutput = string.Format(" copyToOutputDirectory=\"Always\""); copyToOutput = string.Format(" copyToOutputDirectory=\"Always\"");
break; break;
case CopyToOutput.PreserveNewest: case CopyToOutput.PreserveNewest:
copyToOutput = string.Format(" copyToOutputDirectory=\"PreserveNewest\""); copyToOutput = string.Format(" copyToOutputDirectory=\"PreserveNewest\"");
break; break;
} }
// Sort of a hack, we try and resolve the path and make it relative, if we can. // Sort of a hack, we try and resolve the path and make it relative, if we can.
string filePath = PrependPath(file); string filePath = PrependPath(file);
ss.WriteLine(" <File name=\"{0}\" subtype=\"Code\" buildaction=\"{1}\"{2}{3}{4} />", ss.WriteLine(" <File name=\"{0}\" subtype=\"Code\" buildaction=\"{1}\"{2}{3}{4} />",
filePath, buildAction, dependson, resource_id, copyToOutput); filePath, buildAction, dependson, resource_id, copyToOutput);
} }
ss.WriteLine(" </Contents>"); ss.WriteLine(" </Contents>");
ss.WriteLine(" <References>"); ss.WriteLine(" <References>");
foreach(ReferenceNode refr in project.References) foreach(ReferenceNode refr in project.References)
{ {
ss.WriteLine(" {0}", BuildReference(solution, refr)); ss.WriteLine(" {0}", BuildReference(solution, refr));
} }
ss.WriteLine(" </References>"); ss.WriteLine(" </References>");
ss.WriteLine("</Project>"); ss.WriteLine("</Project>");
} }
m_Kernel.CurrentWorkingDirectory.Pop(); m_Kernel.CurrentWorkingDirectory.Pop();
} }
private void WriteCombine(SolutionNode solution) private void WriteCombine(SolutionNode solution)
{ {
m_Kernel.Log.Write("Creating MonoDevelop combine and project files"); m_Kernel.Log.Write("Creating MonoDevelop combine and project files");
foreach(ProjectNode project in solution.Projects) foreach(ProjectNode project in solution.Projects)
{ {
if(m_Kernel.AllowProject(project.FilterGroups)) if(m_Kernel.AllowProject(project.FilterGroups))
{ {
m_Kernel.Log.Write("...Creating project: {0}", project.Name); m_Kernel.Log.Write("...Creating project: {0}", project.Name);
WriteProject(solution, project); WriteProject(solution, project);
} }
} }
m_Kernel.Log.Write(""); m_Kernel.Log.Write("");
string combFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "mds"); string combFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "mds");
StreamWriter ss = new StreamWriter(combFile); StreamWriter ss = new StreamWriter(combFile);
m_Kernel.CurrentWorkingDirectory.Push(); m_Kernel.CurrentWorkingDirectory.Push();
Helper.SetCurrentDir(Path.GetDirectoryName(combFile)); Helper.SetCurrentDir(Path.GetDirectoryName(combFile));
int count = 0; int count = 0;
using(ss) using(ss)
{ {
ss.WriteLine("<Combine name=\"{0}\" fileversion=\"2.0\" description=\"\">", solution.Name); ss.WriteLine("<Combine name=\"{0}\" fileversion=\"2.0\" description=\"\">", solution.Name);
count = 0; count = 0;
foreach(ConfigurationNode conf in solution.Configurations) foreach(ConfigurationNode conf in solution.Configurations)
{ {
if(count == 0) if(count == 0)
{ {
ss.WriteLine(" <Configurations active=\"{0}\">", conf.Name); ss.WriteLine(" <Configurations active=\"{0}\">", conf.Name);
} }
ss.WriteLine(" <Configuration name=\"{0}\" ctype=\"CombineConfiguration\">", conf.Name); ss.WriteLine(" <Configuration name=\"{0}\" ctype=\"CombineConfiguration\">", conf.Name);
foreach(ProjectNode project in solution.Projects) foreach(ProjectNode project in solution.Projects)
{ {
ss.WriteLine(" <Entry configuration=\"{1}\" build=\"True\" name=\"{0}\" />", project.Name, conf.Name); ss.WriteLine(" <Entry configuration=\"{1}\" build=\"True\" name=\"{0}\" />", project.Name, conf.Name);
} }
ss.WriteLine(" </Configuration>"); ss.WriteLine(" </Configuration>");
count++; count++;
} }
ss.WriteLine(" </Configurations>"); ss.WriteLine(" </Configurations>");
count = 0; count = 0;
foreach(ProjectNode project in solution.Projects) foreach(ProjectNode project in solution.Projects)
{ {
if(count == 0) if(count == 0)
ss.WriteLine(" <StartMode startupentry=\"{0}\" single=\"True\">", project.Name); ss.WriteLine(" <StartMode startupentry=\"{0}\" single=\"True\">", project.Name);
ss.WriteLine(" <Execute type=\"None\" entry=\"{0}\" />", project.Name); ss.WriteLine(" <Execute type=\"None\" entry=\"{0}\" />", project.Name);
count++; count++;
} }
ss.WriteLine(" </StartMode>"); ss.WriteLine(" </StartMode>");
ss.WriteLine(" <Entries>"); ss.WriteLine(" <Entries>");
foreach(ProjectNode project in solution.Projects) foreach(ProjectNode project in solution.Projects)
{ {
string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath); string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
ss.WriteLine(" <Entry filename=\"{0}\" />", ss.WriteLine(" <Entry filename=\"{0}\" />",
Helper.MakeFilePath(path, project.Name, "mdp")); Helper.MakeFilePath(path, project.Name, "mdp"));
} }
ss.WriteLine(" </Entries>"); ss.WriteLine(" </Entries>");
ss.WriteLine("</Combine>"); ss.WriteLine("</Combine>");
} }
m_Kernel.CurrentWorkingDirectory.Pop(); m_Kernel.CurrentWorkingDirectory.Pop();
} }
private void CleanProject(ProjectNode project) private void CleanProject(ProjectNode project)
{ {
m_Kernel.Log.Write("...Cleaning project: {0}", project.Name); m_Kernel.Log.Write("...Cleaning project: {0}", project.Name);
string projectFile = Helper.MakeFilePath(project.FullPath, project.Name, "mdp"); string projectFile = Helper.MakeFilePath(project.FullPath, project.Name, "mdp");
Helper.DeleteIfExists(projectFile); Helper.DeleteIfExists(projectFile);
} }
private void CleanSolution(SolutionNode solution) private void CleanSolution(SolutionNode solution)
{ {
m_Kernel.Log.Write("Cleaning MonoDevelop combine and project files for", solution.Name); m_Kernel.Log.Write("Cleaning MonoDevelop combine and project files for", solution.Name);
string slnFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "mds"); string slnFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "mds");
Helper.DeleteIfExists(slnFile); Helper.DeleteIfExists(slnFile);
foreach(ProjectNode project in solution.Projects) foreach(ProjectNode project in solution.Projects)
{ {
CleanProject(project); CleanProject(project);
} }
m_Kernel.Log.Write(""); m_Kernel.Log.Write("");
} }
#endregion #endregion
#region ITarget Members #region ITarget Members
/// <summary> /// <summary>
/// Writes the specified kern. /// Writes the specified kern.
/// </summary> /// </summary>
/// <param name="kern">The kern.</param> /// <param name="kern">The kern.</param>
public void Write(Kernel kern) public void Write(Kernel kern)
{ {
if( kern == null ) if( kern == null )
{ {
throw new ArgumentNullException("kern"); throw new ArgumentNullException("kern");
} }
m_Kernel = kern; m_Kernel = kern;
foreach(SolutionNode solution in kern.Solutions) foreach(SolutionNode solution in kern.Solutions)
{ {
WriteCombine(solution); WriteCombine(solution);
} }
m_Kernel = null; m_Kernel = null;
} }
/// <summary> /// <summary>
/// Cleans the specified kern. /// Cleans the specified kern.
/// </summary> /// </summary>
/// <param name="kern">The kern.</param> /// <param name="kern">The kern.</param>
public virtual void Clean(Kernel kern) public virtual void Clean(Kernel kern)
{ {
if( kern == null ) if( kern == null )
{ {
throw new ArgumentNullException("kern"); throw new ArgumentNullException("kern");
} }
m_Kernel = kern; m_Kernel = kern;
foreach(SolutionNode sol in kern.Solutions) foreach(SolutionNode sol in kern.Solutions)
{ {
CleanSolution(sol); CleanSolution(sol);
} }
m_Kernel = null; m_Kernel = null;
} }
/// <summary> /// <summary>
/// Gets the name. /// Gets the name.
/// </summary> /// </summary>
/// <value>The name.</value> /// <value>The name.</value>
public string Name public string Name
{ {
get get
{ {
return "sharpdev"; return "sharpdev";
} }
} }
#endregion #endregion
} }
} }

699
Prebuild/src/Core/Targets/NAntTarget.cs
View File

@ -47,36 +47,36 @@ using Prebuild.Core.Utilities;
namespace Prebuild.Core.Targets namespace Prebuild.Core.Targets
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[Target("nant")] [Target("nant")]
public class NAntTarget : ITarget public class NAntTarget : ITarget
{ {
#region Fields #region Fields
private Kernel m_Kernel; private Kernel m_Kernel;
#endregion #endregion
#region Private Methods #region Private Methods
private static string PrependPath(string path) private static string PrependPath(string path)
{ {
string tmpPath = Helper.NormalizePath(path, '/'); string tmpPath = Helper.NormalizePath(path, '/');
Regex regex = new Regex(@"(\w):/(\w+)"); Regex regex = new Regex(@"(\w):/(\w+)");
Match match = regex.Match(tmpPath); Match match = regex.Match(tmpPath);
//if(match.Success || tmpPath[0] == '.' || tmpPath[0] == '/') //if(match.Success || tmpPath[0] == '.' || tmpPath[0] == '/')
//{ //{
tmpPath = Helper.NormalizePath(tmpPath); tmpPath = Helper.NormalizePath(tmpPath);
//} //}
// else // else
// { // {
// tmpPath = Helper.NormalizePath("./" + tmpPath); // tmpPath = Helper.NormalizePath("./" + tmpPath);
// } // }
return tmpPath; return tmpPath;
} }
private static string BuildReference(SolutionNode solution, ProjectNode currentProject, ReferenceNode refr) private static string BuildReference(SolutionNode solution, ProjectNode currentProject, ReferenceNode refr)
{ {
@ -113,7 +113,7 @@ namespace Prebuild.Core.Targets
return refr.Name + ".dll"; return refr.Name + ".dll";
} }
public static string GetRefFileName(string refName) public static string GetRefFileName(string refName)
{ {
if (ExtensionSpecified(refName)) if (ExtensionSpecified(refName))
{ {
@ -140,11 +140,11 @@ namespace Prebuild.Core.Targets
return extension; return extension;
} }
private static string FindFileReference(string refName, ProjectNode project) private static string FindFileReference(string refName, ProjectNode project)
{ {
foreach (ReferencePathNode refPath in project.ReferencePaths) foreach (ReferencePathNode refPath in project.ReferencePaths)
{ {
string fullPath = Helper.MakeFilePath(refPath.Path, refName); string fullPath = Helper.MakeFilePath(refPath.Path, refName);
if (File.Exists(fullPath)) if (File.Exists(fullPath))
{ {
@ -153,10 +153,10 @@ namespace Prebuild.Core.Targets
fullPath = Helper.MakeFilePath(refPath.Path, refName, "dll"); fullPath = Helper.MakeFilePath(refPath.Path, refName, "dll");
if (File.Exists(fullPath)) if (File.Exists(fullPath))
{ {
return fullPath; return fullPath;
} }
fullPath = Helper.MakeFilePath(refPath.Path, refName, "exe"); fullPath = Helper.MakeFilePath(refPath.Path, refName, "exe");
@ -164,162 +164,205 @@ namespace Prebuild.Core.Targets
{ {
return fullPath; return fullPath;
} }
} }
return null; return null;
} }
/// <summary> /// <summary>
/// Gets the XML doc file. /// Gets the XML doc file.
/// </summary> /// </summary>
/// <param name="project">The project.</param> /// <param name="project">The project.</param>
/// <param name="conf">The conf.</param> /// <param name="conf">The conf.</param>
/// <returns></returns> /// <returns></returns>
public static string GetXmlDocFile(ProjectNode project, ConfigurationNode conf) public static string GetXmlDocFile(ProjectNode project, ConfigurationNode conf)
{ {
if (conf == null) if (conf == null)
{ {
throw new ArgumentNullException("conf"); throw new ArgumentNullException("conf");
} }
if (project == null) if (project == null)
{ {
throw new ArgumentNullException("project"); throw new ArgumentNullException("project");
} }
string docFile = (string)conf.Options["XmlDocFile"]; string docFile = (string)conf.Options["XmlDocFile"];
// if(docFile != null && docFile.Length == 0)//default to assembly name if not specified // if(docFile != null && docFile.Length == 0)//default to assembly name if not specified
// { // {
// return Path.GetFileNameWithoutExtension(project.AssemblyName) + ".xml"; // return Path.GetFileNameWithoutExtension(project.AssemblyName) + ".xml";
// } // }
return docFile; return docFile;
} }
private void WriteProject(SolutionNode solution, ProjectNode project) private void WriteProject(SolutionNode solution, ProjectNode project)
{ {
string projFile = Helper.MakeFilePath(project.FullPath, project.Name + GetProjectExtension(project), "build"); string projFile = Helper.MakeFilePath(project.FullPath, project.Name + GetProjectExtension(project), "build");
StreamWriter ss = new StreamWriter(projFile); StreamWriter ss = new StreamWriter(projFile);
m_Kernel.CurrentWorkingDirectory.Push(); m_Kernel.CurrentWorkingDirectory.Push();
Helper.SetCurrentDir(Path.GetDirectoryName(projFile)); Helper.SetCurrentDir(Path.GetDirectoryName(projFile));
bool hasDoc = false; bool hasDoc = false;
using (ss) using (ss)
{ {
ss.WriteLine("<?xml version=\"1.0\" ?>"); ss.WriteLine("<?xml version=\"1.0\" ?>");
ss.WriteLine("<project name=\"{0}\" default=\"build\">", project.Name); ss.WriteLine("<project name=\"{0}\" default=\"build\">", project.Name);
ss.WriteLine(" <target name=\"{0}\">", "build"); ss.WriteLine(" <target name=\"{0}\">", "build");
ss.WriteLine(" <echo message=\"Build Directory is ${project::get-base-directory()}/${build.dir}\" />"); ss.WriteLine(" <echo message=\"Build Directory is ${project::get-base-directory()}/${build.dir}\" />");
ss.WriteLine(" <mkdir dir=\"${project::get-base-directory()}/${build.dir}\" />"); ss.WriteLine(" <mkdir dir=\"${project::get-base-directory()}/${build.dir}\" />");
ss.WriteLine(" <copy todir=\"${project::get-base-directory()}/${build.dir}\" flatten=\"true\">");
ss.WriteLine(" <fileset basedir=\"${project::get-base-directory()}\">");
foreach (ReferenceNode refr in project.References)
{
if (refr.LocalCopy)
{
ss.WriteLine(" <include name=\"{0}", Helper.NormalizePath(Helper.MakePathRelativeTo(project.FullPath, BuildReference(solution, project, refr)) + "\" />", '/'));
}
}
ss.Write(" <csc "); ss.WriteLine(" </fileset>");
ss.Write(" target=\"{0}\"", project.Type.ToString().ToLower()); ss.WriteLine(" </copy>");
ss.Write(" debug=\"{0}\"", "${build.debug}"); if (project.ConfigFile != null && project.ConfigFile.Length!=0)
ss.Write(" platform=\"${build.platform}\""); {
ss.Write(" <copy file=\"" + project.ConfigFile + "\" tofile=\"${project::get-base-directory()}/${build.dir}/${project::get-name()}");
if (project.Type == ProjectType.Library)
{
ss.Write(".dll.config\"");
}
else
{
ss.Write(".exe.config\"");
}
ss.WriteLine(" />");
}
// Add the content files to just be copied
ss.WriteLine(" {0}", "<copy todir=\"${project::get-base-directory()}/${build.dir}\">");
ss.WriteLine(" {0}", "<fileset basedir=\".\">");
foreach (string file in project.Files)
{
// Ignore if we aren't content
if (project.Files.GetBuildAction(file) != BuildAction.Content)
continue;
// Create a include tag
ss.WriteLine(" {0}", "<include name=\"" + Helper.NormalizePath(PrependPath(file), '/') + "\" />");
}
ss.WriteLine(" {0}", "</fileset>");
ss.WriteLine(" {0}", "</copy>");
ss.Write(" <csc ");
ss.Write(" target=\"{0}\"", project.Type.ToString().ToLower());
ss.Write(" debug=\"{0}\"", "${build.debug}");
ss.Write(" platform=\"${build.platform}\"");
foreach (ConfigurationNode conf in project.Configurations) foreach (ConfigurationNode conf in project.Configurations)
{ {
if (conf.Options.KeyFile != "") if (conf.Options.KeyFile != "")
{ {
ss.Write(" keyfile=\"{0}\"", conf.Options.KeyFile); ss.Write(" keyfile=\"{0}\"", conf.Options.KeyFile);
break; break;
} }
} }
foreach (ConfigurationNode conf in project.Configurations) foreach (ConfigurationNode conf in project.Configurations)
{ {
ss.Write(" unsafe=\"{0}\"", conf.Options.AllowUnsafe); ss.Write(" unsafe=\"{0}\"", conf.Options.AllowUnsafe);
break; break;
} }
foreach (ConfigurationNode conf in project.Configurations) foreach (ConfigurationNode conf in project.Configurations)
{ {
ss.Write(" warnaserror=\"{0}\"", conf.Options.WarningsAsErrors); ss.Write(" warnaserror=\"{0}\"", conf.Options.WarningsAsErrors);
break; break;
} }
foreach (ConfigurationNode conf in project.Configurations) foreach (ConfigurationNode conf in project.Configurations)
{ {
ss.Write(" define=\"{0}\"", conf.Options.CompilerDefines); ss.Write(" define=\"{0}\"", conf.Options.CompilerDefines);
break; break;
} }
foreach (ConfigurationNode conf in project.Configurations) foreach (ConfigurationNode conf in project.Configurations)
{ {
ss.Write(" nostdlib=\"{0}\"", conf.Options["NoStdLib"]); ss.Write(" nostdlib=\"{0}\"", conf.Options["NoStdLib"]);
break; break;
} }
ss.Write(" main=\"{0}\"", project.StartupObject); ss.Write(" main=\"{0}\"", project.StartupObject);
foreach (ConfigurationNode conf in project.Configurations) foreach (ConfigurationNode conf in project.Configurations)
{ {
if (GetXmlDocFile(project, conf) != "") if (GetXmlDocFile(project, conf) != "")
{ {
ss.Write(" doc=\"{0}\"", "${project::get-base-directory()}/${build.dir}/" + GetXmlDocFile(project, conf)); ss.Write(" doc=\"{0}\"", "${project::get-base-directory()}/${build.dir}/" + GetXmlDocFile(project, conf));
hasDoc = true; hasDoc = true;
} }
break; break;
} }
ss.Write(" output=\"{0}", "${project::get-base-directory()}/${build.dir}/${project::get-name()}"); ss.Write(" output=\"{0}", "${project::get-base-directory()}/${build.dir}/${project::get-name()}");
if (project.Type == ProjectType.Library) if (project.Type == ProjectType.Library)
{ {
ss.Write(".dll\""); ss.Write(".dll\"");
} }
else else
{ {
ss.Write(".exe\""); ss.Write(".exe\"");
} }
if (project.AppIcon != null && project.AppIcon.Length != 0) if (project.AppIcon != null && project.AppIcon.Length != 0)
{ {
ss.Write(" win32icon=\"{0}\"", Helper.NormalizePath(project.AppIcon, '/')); ss.Write(" win32icon=\"{0}\"", Helper.NormalizePath(project.AppIcon, '/'));
} }
// This disables a very different behavior between VS and NAnt. With Nant, // This disables a very different behavior between VS and NAnt. With Nant,
// If you have using System.Xml; it will ensure System.Xml.dll is referenced, // If you have using System.Xml; it will ensure System.Xml.dll is referenced,
// but not in VS. This will force the behaviors to match, so when it works // but not in VS. This will force the behaviors to match, so when it works
// in nant, it will work in VS. // in nant, it will work in VS.
ss.Write(" noconfig=\"true\""); ss.Write(" noconfig=\"true\"");
ss.WriteLine(">"); ss.WriteLine(">");
ss.WriteLine(" <resources prefix=\"{0}\" dynamicprefix=\"true\" >", project.RootNamespace); ss.WriteLine(" <resources prefix=\"{0}\" dynamicprefix=\"true\" >", project.RootNamespace);
foreach (string file in project.Files) foreach (string file in project.Files)
{ {
switch (project.Files.GetBuildAction(file)) switch (project.Files.GetBuildAction(file))
{ {
case BuildAction.EmbeddedResource: case BuildAction.EmbeddedResource:
ss.WriteLine(" {0}", "<include name=\"" + Helper.NormalizePath(PrependPath(file), '/') + "\" />"); ss.WriteLine(" {0}", "<include name=\"" + Helper.NormalizePath(PrependPath(file), '/') + "\" />");
break; break;
default: default:
if (project.Files.GetSubType(file) != SubType.Code && project.Files.GetSubType(file) != SubType.Settings) if (project.Files.GetSubType(file) != SubType.Code && project.Files.GetSubType(file) != SubType.Settings)
{ {
ss.WriteLine(" <include name=\"{0}\" />", file.Substring(0, file.LastIndexOf('.')) + ".resx"); ss.WriteLine(" <include name=\"{0}\" />", file.Substring(0, file.LastIndexOf('.')) + ".resx");
} }
break; break;
} }
} }
//if (project.Files.GetSubType(file).ToString() != "Code") //if (project.Files.GetSubType(file).ToString() != "Code")
//{ //{
// ps.WriteLine(" <EmbeddedResource Include=\"{0}\">", file.Substring(0, file.LastIndexOf('.')) + ".resx"); // ps.WriteLine(" <EmbeddedResource Include=\"{0}\">", file.Substring(0, file.LastIndexOf('.')) + ".resx");
ss.WriteLine(" </resources>"); ss.WriteLine(" </resources>");
ss.WriteLine(" <sources failonempty=\"true\">"); ss.WriteLine(" <sources failonempty=\"true\">");
foreach (string file in project.Files) foreach (string file in project.Files)
{ {
switch (project.Files.GetBuildAction(file)) switch (project.Files.GetBuildAction(file))
{ {
case BuildAction.Compile: case BuildAction.Compile:
ss.WriteLine(" <include name=\"" + Helper.NormalizePath(PrependPath(file), '/') + "\" />"); ss.WriteLine(" <include name=\"" + Helper.NormalizePath(PrependPath(file), '/') + "\" />");
break; break;
default: default:
break; break;
} }
} }
ss.WriteLine(" </sources>"); ss.WriteLine(" </sources>");
ss.WriteLine(" <references basedir=\"${project::get-base-directory()}\">"); ss.WriteLine(" <references basedir=\"${project::get-base-directory()}\">");
ss.WriteLine(" <lib>"); ss.WriteLine(" <lib>");
ss.WriteLine(" <include name=\"${project::get-base-directory()}\" />"); ss.WriteLine(" <include name=\"${project::get-base-directory()}\" />");
foreach(ReferencePathNode refPath in project.ReferencePaths) foreach(ReferencePathNode refPath in project.ReferencePaths)
{ {
ss.WriteLine(" <include name=\"${project::get-base-directory()}/" + refPath.Path.TrimEnd('/', '\\') + "\" />"); ss.WriteLine(" <include name=\"${project::get-base-directory()}/" + refPath.Path.TrimEnd('/', '\\') + "\" />");
} }
ss.WriteLine(" </lib>"); ss.WriteLine(" </lib>");
foreach (ReferenceNode refr in project.References) foreach (ReferenceNode refr in project.References)
{ {
string path = Helper.NormalizePath(Helper.MakePathRelativeTo(project.FullPath, BuildReference(solution, project, refr)), '/'); string path = Helper.NormalizePath(Helper.MakePathRelativeTo(project.FullPath, BuildReference(solution, project, refr)), '/');
if (refr.Path != null) { if (refr.Path != null) {
if (ExtensionSpecified(refr.Name)) if (ExtensionSpecified(refr.Name))
{ {
@ -334,12 +377,12 @@ namespace Prebuild.Core.Targets
{ {
ss.WriteLine (" <include name=\"" + path + "\" />"); ss.WriteLine (" <include name=\"" + path + "\" />");
} }
} }
ss.WriteLine(" </references>"); ss.WriteLine(" </references>");
ss.WriteLine(" </csc>"); ss.WriteLine(" </csc>");
foreach (ConfigurationNode conf in project.Configurations) foreach (ConfigurationNode conf in project.Configurations)
{ {
if (!String.IsNullOrEmpty(conf.Options.OutputPath)) if (!String.IsNullOrEmpty(conf.Options.OutputPath))
{ {
@ -361,170 +404,170 @@ namespace Prebuild.Core.Targets
} }
} }
ss.WriteLine(" </target>"); ss.WriteLine(" </target>");
ss.WriteLine(" <target name=\"clean\">"); ss.WriteLine(" <target name=\"clean\">");
ss.WriteLine(" <delete dir=\"${bin.dir}\" failonerror=\"false\" />"); ss.WriteLine(" <delete dir=\"${bin.dir}\" failonerror=\"false\" />");
ss.WriteLine(" <delete dir=\"${obj.dir}\" failonerror=\"false\" />"); ss.WriteLine(" <delete dir=\"${obj.dir}\" failonerror=\"false\" />");
ss.WriteLine(" </target>"); ss.WriteLine(" </target>");
ss.WriteLine(" <target name=\"doc\" description=\"Creates documentation.\">"); ss.WriteLine(" <target name=\"doc\" description=\"Creates documentation.\">");
if (hasDoc) if (hasDoc)
{ {
ss.WriteLine(" <property name=\"doc.target\" value=\"\" />"); ss.WriteLine(" <property name=\"doc.target\" value=\"\" />");
ss.WriteLine(" <if test=\"${platform::is-unix()}\">"); ss.WriteLine(" <if test=\"${platform::is-unix()}\">");
ss.WriteLine(" <property name=\"doc.target\" value=\"Web\" />"); ss.WriteLine(" <property name=\"doc.target\" value=\"Web\" />");
ss.WriteLine(" </if>"); ss.WriteLine(" </if>");
ss.WriteLine(" <ndoc failonerror=\"false\" verbose=\"true\">"); ss.WriteLine(" <ndoc failonerror=\"false\" verbose=\"true\">");
ss.WriteLine(" <assemblies basedir=\"${project::get-base-directory()}\">"); ss.WriteLine(" <assemblies basedir=\"${project::get-base-directory()}\">");
ss.Write(" <include name=\"${build.dir}/${project::get-name()}"); ss.Write(" <include name=\"${build.dir}/${project::get-name()}");
if (project.Type == ProjectType.Library) if (project.Type == ProjectType.Library)
{ {
ss.WriteLine(".dll\" />"); ss.WriteLine(".dll\" />");
} }
else else
{ {
ss.WriteLine(".exe\" />"); ss.WriteLine(".exe\" />");
} }
ss.WriteLine(" </assemblies>"); ss.WriteLine(" </assemblies>");
ss.WriteLine(" <summaries basedir=\"${project::get-base-directory()}\">"); ss.WriteLine(" <summaries basedir=\"${project::get-base-directory()}\">");
ss.WriteLine(" <include name=\"${build.dir}/${project::get-name()}.xml\"/>"); ss.WriteLine(" <include name=\"${build.dir}/${project::get-name()}.xml\"/>");
ss.WriteLine(" </summaries>"); ss.WriteLine(" </summaries>");
ss.WriteLine(" <referencepaths basedir=\"${project::get-base-directory()}\">"); ss.WriteLine(" <referencepaths basedir=\"${project::get-base-directory()}\">");
ss.WriteLine(" <include name=\"${build.dir}\" />"); ss.WriteLine(" <include name=\"${build.dir}\" />");
// foreach(ReferenceNode refr in project.References) // foreach(ReferenceNode refr in project.References)
// { // {
// string path = Helper.NormalizePath(Helper.MakePathRelativeTo(project.FullPath, BuildReferencePath(solution, refr)), '/'); // string path = Helper.NormalizePath(Helper.MakePathRelativeTo(project.FullPath, BuildReferencePath(solution, refr)), '/');
// if (path != "") // if (path != "")
// { // {
// ss.WriteLine(" <include name=\"{0}\" />", path); // ss.WriteLine(" <include name=\"{0}\" />", path);
// } // }
// } // }
ss.WriteLine(" </referencepaths>"); ss.WriteLine(" </referencepaths>");
ss.WriteLine(" <documenters>"); ss.WriteLine(" <documenters>");
ss.WriteLine(" <documenter name=\"MSDN\">"); ss.WriteLine(" <documenter name=\"MSDN\">");
ss.WriteLine(" <property name=\"OutputDirectory\" value=\"${project::get-base-directory()}/${build.dir}/doc/${project::get-name()}\" />"); ss.WriteLine(" <property name=\"OutputDirectory\" value=\"${project::get-base-directory()}/${build.dir}/doc/${project::get-name()}\" />");
ss.WriteLine(" <property name=\"OutputTarget\" value=\"${doc.target}\" />"); ss.WriteLine(" <property name=\"OutputTarget\" value=\"${doc.target}\" />");
ss.WriteLine(" <property name=\"HtmlHelpName\" value=\"${project::get-name()}\" />"); ss.WriteLine(" <property name=\"HtmlHelpName\" value=\"${project::get-name()}\" />");
ss.WriteLine(" <property name=\"IncludeFavorites\" value=\"False\" />"); ss.WriteLine(" <property name=\"IncludeFavorites\" value=\"False\" />");
ss.WriteLine(" <property name=\"Title\" value=\"${project::get-name()} SDK Documentation\" />"); ss.WriteLine(" <property name=\"Title\" value=\"${project::get-name()} SDK Documentation\" />");
ss.WriteLine(" <property name=\"SplitTOCs\" value=\"False\" />"); ss.WriteLine(" <property name=\"SplitTOCs\" value=\"False\" />");
ss.WriteLine(" <property name=\"DefaulTOC\" value=\"\" />"); ss.WriteLine(" <property name=\"DefaulTOC\" value=\"\" />");
ss.WriteLine(" <property name=\"ShowVisualBasic\" value=\"True\" />"); ss.WriteLine(" <property name=\"ShowVisualBasic\" value=\"True\" />");
ss.WriteLine(" <property name=\"AutoDocumentConstructors\" value=\"True\" />"); ss.WriteLine(" <property name=\"AutoDocumentConstructors\" value=\"True\" />");
ss.WriteLine(" <property name=\"ShowMissingSummaries\" value=\"${build.debug}\" />"); ss.WriteLine(" <property name=\"ShowMissingSummaries\" value=\"${build.debug}\" />");
ss.WriteLine(" <property name=\"ShowMissingRemarks\" value=\"${build.debug}\" />"); ss.WriteLine(" <property name=\"ShowMissingRemarks\" value=\"${build.debug}\" />");
ss.WriteLine(" <property name=\"ShowMissingParams\" value=\"${build.debug}\" />"); ss.WriteLine(" <property name=\"ShowMissingParams\" value=\"${build.debug}\" />");
ss.WriteLine(" <property name=\"ShowMissingReturns\" value=\"${build.debug}\" />"); ss.WriteLine(" <property name=\"ShowMissingReturns\" value=\"${build.debug}\" />");
ss.WriteLine(" <property name=\"ShowMissingValues\" value=\"${build.debug}\" />"); ss.WriteLine(" <property name=\"ShowMissingValues\" value=\"${build.debug}\" />");
ss.WriteLine(" <property name=\"DocumentInternals\" value=\"False\" />"); ss.WriteLine(" <property name=\"DocumentInternals\" value=\"False\" />");
ss.WriteLine(" <property name=\"DocumentPrivates\" value=\"False\" />"); ss.WriteLine(" <property name=\"DocumentPrivates\" value=\"False\" />");
ss.WriteLine(" <property name=\"DocumentProtected\" value=\"True\" />"); ss.WriteLine(" <property name=\"DocumentProtected\" value=\"True\" />");
ss.WriteLine(" <property name=\"DocumentEmptyNamespaces\" value=\"${build.debug}\" />"); ss.WriteLine(" <property name=\"DocumentEmptyNamespaces\" value=\"${build.debug}\" />");
ss.WriteLine(" <property name=\"IncludeAssemblyVersion\" value=\"True\" />"); ss.WriteLine(" <property name=\"IncludeAssemblyVersion\" value=\"True\" />");
ss.WriteLine(" </documenter>"); ss.WriteLine(" </documenter>");
ss.WriteLine(" </documenters>"); ss.WriteLine(" </documenters>");
ss.WriteLine(" </ndoc>"); ss.WriteLine(" </ndoc>");
} }
ss.WriteLine(" </target>"); ss.WriteLine(" </target>");
ss.WriteLine("</project>"); ss.WriteLine("</project>");
} }
m_Kernel.CurrentWorkingDirectory.Pop(); m_Kernel.CurrentWorkingDirectory.Pop();
} }
private void WriteCombine(SolutionNode solution) private void WriteCombine(SolutionNode solution)
{ {
m_Kernel.Log.Write("Creating NAnt build files"); m_Kernel.Log.Write("Creating NAnt build files");
foreach (ProjectNode project in solution.Projects) foreach (ProjectNode project in solution.Projects)
{ {
if (m_Kernel.AllowProject(project.FilterGroups)) if (m_Kernel.AllowProject(project.FilterGroups))
{ {
m_Kernel.Log.Write("...Creating project: {0}", project.Name); m_Kernel.Log.Write("...Creating project: {0}", project.Name);
WriteProject(solution, project); WriteProject(solution, project);
} }
} }
m_Kernel.Log.Write(""); m_Kernel.Log.Write("");
string combFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "build"); string combFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "build");
StreamWriter ss = new StreamWriter(combFile); StreamWriter ss = new StreamWriter(combFile);
m_Kernel.CurrentWorkingDirectory.Push(); m_Kernel.CurrentWorkingDirectory.Push();
Helper.SetCurrentDir(Path.GetDirectoryName(combFile)); Helper.SetCurrentDir(Path.GetDirectoryName(combFile));
using (ss) using (ss)
{ {
ss.WriteLine("<?xml version=\"1.0\" ?>"); ss.WriteLine("<?xml version=\"1.0\" ?>");
ss.WriteLine("<project name=\"{0}\" default=\"build\">", solution.Name); ss.WriteLine("<project name=\"{0}\" default=\"build\">", solution.Name);
ss.WriteLine(" <echo message=\"Using '${nant.settings.currentframework}' Framework\"/>"); ss.WriteLine(" <echo message=\"Using '${nant.settings.currentframework}' Framework\"/>");
ss.WriteLine(); ss.WriteLine();
//ss.WriteLine(" <property name=\"dist.dir\" value=\"dist\" />"); //ss.WriteLine(" <property name=\"dist.dir\" value=\"dist\" />");
//ss.WriteLine(" <property name=\"source.dir\" value=\"source\" />"); //ss.WriteLine(" <property name=\"source.dir\" value=\"source\" />");
ss.WriteLine(" <property name=\"bin.dir\" value=\"bin\" />"); ss.WriteLine(" <property name=\"bin.dir\" value=\"bin\" />");
ss.WriteLine(" <property name=\"obj.dir\" value=\"obj\" />"); ss.WriteLine(" <property name=\"obj.dir\" value=\"obj\" />");
ss.WriteLine(" <property name=\"doc.dir\" value=\"doc\" />"); ss.WriteLine(" <property name=\"doc.dir\" value=\"doc\" />");
ss.WriteLine(" <property name=\"project.main.dir\" value=\"${project::get-base-directory()}\" />"); ss.WriteLine(" <property name=\"project.main.dir\" value=\"${project::get-base-directory()}\" />");
// Use the active configuration, which is the first configuration name in the prebuild file. // Use the active configuration, which is the first configuration name in the prebuild file.
Dictionary<string,string> emittedConfigurations = new Dictionary<string, string>(); Dictionary<string,string> emittedConfigurations = new Dictionary<string, string>();
ss.WriteLine(" <property name=\"project.config\" value=\"{0}\" />", solution.ActiveConfig); ss.WriteLine(" <property name=\"project.config\" value=\"{0}\" />", solution.ActiveConfig);
ss.WriteLine(); ss.WriteLine();
foreach (ConfigurationNode conf in solution.Configurations) foreach (ConfigurationNode conf in solution.Configurations)
{ {
// If the name isn't in the emitted configurations, we give a high level target to the // If the name isn't in the emitted configurations, we give a high level target to the
// platform specific on. This lets "Debug" point to "Debug-AnyCPU". // platform specific on. This lets "Debug" point to "Debug-AnyCPU".
if (!emittedConfigurations.ContainsKey(conf.Name)) if (!emittedConfigurations.ContainsKey(conf.Name))
{ {
// Add it to the dictionary so we only emit one. // Add it to the dictionary so we only emit one.
emittedConfigurations.Add(conf.Name, conf.Platform); emittedConfigurations.Add(conf.Name, conf.Platform);
// Write out the target block. // Write out the target block.
ss.WriteLine(" <target name=\"{0}\" description=\"{0}|{1}\" depends=\"{0}-{1}\">", conf.Name, conf.Platform); ss.WriteLine(" <target name=\"{0}\" description=\"{0}|{1}\" depends=\"{0}-{1}\">", conf.Name, conf.Platform);
ss.WriteLine(" </target>"); ss.WriteLine(" </target>");
ss.WriteLine(); ss.WriteLine();
} }
// Write out the target for the configuration. // Write out the target for the configuration.
ss.WriteLine(" <target name=\"{0}-{1}\" description=\"{0}|{1}\">", conf.Name, conf.Platform); ss.WriteLine(" <target name=\"{0}-{1}\" description=\"{0}|{1}\">", conf.Name, conf.Platform);
ss.WriteLine(" <property name=\"project.config\" value=\"{0}\" />", conf.Name); ss.WriteLine(" <property name=\"project.config\" value=\"{0}\" />", conf.Name);
ss.WriteLine(" <property name=\"build.debug\" value=\"{0}\" />", conf.Options["DebugInformation"].ToString().ToLower()); ss.WriteLine(" <property name=\"build.debug\" value=\"{0}\" />", conf.Options["DebugInformation"].ToString().ToLower());
ss.WriteLine("\t\t <property name=\"build.platform\" value=\"{0}\" />", conf.Platform); ss.WriteLine("\t\t <property name=\"build.platform\" value=\"{0}\" />", conf.Platform);
ss.WriteLine(" </target>"); ss.WriteLine(" </target>");
ss.WriteLine(); ss.WriteLine();
} }
ss.WriteLine(" <target name=\"net-1.1\" description=\"Sets framework to .NET 1.1\">"); ss.WriteLine(" <target name=\"net-1.1\" description=\"Sets framework to .NET 1.1\">");
ss.WriteLine(" <property name=\"nant.settings.currentframework\" value=\"net-1.1\" />"); ss.WriteLine(" <property name=\"nant.settings.currentframework\" value=\"net-1.1\" />");
ss.WriteLine(" </target>"); ss.WriteLine(" </target>");
ss.WriteLine(); ss.WriteLine();
ss.WriteLine(" <target name=\"net-2.0\" description=\"Sets framework to .NET 2.0\">"); ss.WriteLine(" <target name=\"net-2.0\" description=\"Sets framework to .NET 2.0\">");
ss.WriteLine(" <property name=\"nant.settings.currentframework\" value=\"net-2.0\" />"); ss.WriteLine(" <property name=\"nant.settings.currentframework\" value=\"net-2.0\" />");
ss.WriteLine(" </target>"); ss.WriteLine(" </target>");
ss.WriteLine(); ss.WriteLine();
ss.WriteLine(" <target name=\"net-3.5\" description=\"Sets framework to .NET 3.5\">"); ss.WriteLine(" <target name=\"net-3.5\" description=\"Sets framework to .NET 3.5\">");
ss.WriteLine(" <property name=\"nant.settings.currentframework\" value=\"net-3.5\" />"); ss.WriteLine(" <property name=\"nant.settings.currentframework\" value=\"net-3.5\" />");
ss.WriteLine(" </target>"); ss.WriteLine(" </target>");
ss.WriteLine(); ss.WriteLine();
ss.WriteLine(" <target name=\"mono-1.0\" description=\"Sets framework to mono 1.0\">"); ss.WriteLine(" <target name=\"mono-1.0\" description=\"Sets framework to mono 1.0\">");
ss.WriteLine(" <property name=\"nant.settings.currentframework\" value=\"mono-1.0\" />"); ss.WriteLine(" <property name=\"nant.settings.currentframework\" value=\"mono-1.0\" />");
ss.WriteLine(" </target>"); ss.WriteLine(" </target>");
ss.WriteLine(); ss.WriteLine();
ss.WriteLine(" <target name=\"mono-2.0\" description=\"Sets framework to mono 2.0\">"); ss.WriteLine(" <target name=\"mono-2.0\" description=\"Sets framework to mono 2.0\">");
ss.WriteLine(" <property name=\"nant.settings.currentframework\" value=\"mono-2.0\" />"); ss.WriteLine(" <property name=\"nant.settings.currentframework\" value=\"mono-2.0\" />");
ss.WriteLine(" </target>"); ss.WriteLine(" </target>");
ss.WriteLine(); ss.WriteLine();
ss.WriteLine(" <target name=\"mono-3.5\" description=\"Sets framework to mono 3.5\">"); ss.WriteLine(" <target name=\"mono-3.5\" description=\"Sets framework to mono 3.5\">");
ss.WriteLine(" <property name=\"nant.settings.currentframework\" value=\"mono-3.5\" />"); ss.WriteLine(" <property name=\"nant.settings.currentframework\" value=\"mono-3.5\" />");
ss.WriteLine(" </target>"); ss.WriteLine(" </target>");
ss.WriteLine(); ss.WriteLine();
ss.WriteLine(" <target name=\"init\" description=\"\">"); ss.WriteLine(" <target name=\"init\" description=\"\">");
ss.WriteLine(" <call target=\"${project.config}\" />"); ss.WriteLine(" <call target=\"${project.config}\" />");
@ -594,24 +637,6 @@ namespace Prebuild.Core.Targets
ss.WriteLine(" <target name=\"clean\" description=\"\">"); ss.WriteLine(" <target name=\"clean\" description=\"\">");
ss.WriteLine(" <echo message=\"Deleting all builds from all configurations\" />"); ss.WriteLine(" <echo message=\"Deleting all builds from all configurations\" />");
//ss.WriteLine(" <delete dir=\"${dist.dir}\" failonerror=\"false\" />"); //ss.WriteLine(" <delete dir=\"${dist.dir}\" failonerror=\"false\" />");
// justincc: FIXME FIXME FIXME - A temporary OpenSim hack to clean up files when "nant clean" is executed.
// Should be replaced with extreme prejudice once anybody finds out if the CleanFiles stuff works or there is
// another working mechanism for specifying this stuff
ss.WriteLine(" <delete failonerror=\"false\">");
ss.WriteLine(" <fileset basedir=\"${bin.dir}\">");
ss.WriteLine(" <include name=\"OpenSim*.dll\"/>");
ss.WriteLine(" <include name=\"OpenSim*.dll.mdb\"/>");
ss.WriteLine(" <include name=\"OpenSim*.exe\"/>");
ss.WriteLine(" <include name=\"OpenSim*.exe.mdb\"/>");
ss.WriteLine(" <include name=\"ScriptEngines/*\"/>");
ss.WriteLine(" <include name=\"Physics/*.dll\"/>");
ss.WriteLine(" <include name=\"Physics/*.dll.mdb\"/>");
ss.WriteLine(" <exclude name=\"OpenSim.32BitLaunch.exe\"/>");
ss.WriteLine(" <exclude name=\"ScriptEngines/Default.lsl\"/>");
ss.WriteLine(" </fileset>");
ss.WriteLine(" </delete>");
if (solution.Cleanup != null && solution.Cleanup.CleanFiles.Count > 0) if (solution.Cleanup != null && solution.Cleanup.CleanFiles.Count > 0)
{ {
foreach (CleanFilesNode cleanFile in solution.Cleanup.CleanFiles) foreach (CleanFilesNode cleanFile in solution.Cleanup.CleanFiles)
@ -625,7 +650,7 @@ namespace Prebuild.Core.Targets
} }
} }
ss.WriteLine(" <delete dir=\"${obj.dir}\" failonerror=\"false\" />"); ss.WriteLine(" <delete dir=\"${obj.dir}\" failonerror=\"false\" />");
foreach (ProjectNode project in solution.Projects) foreach (ProjectNode project in solution.Projects)
{ {
string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath); string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);

70
Prebuild/src/Core/Targets/SharpDevelop2Target.cs
View File

@ -29,11 +29,11 @@ using Prebuild.Core.Attributes;
namespace Prebuild.Core.Targets namespace Prebuild.Core.Targets
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[Target("sharpdev2")] [Target("sharpdev2")]
public class SharpDevelop2Target : VS2005Target public class SharpDevelop2Target : VS2005Target
{ {
#region Properties #region Properties
public override string VersionName public override string VersionName
@ -45,38 +45,38 @@ namespace Prebuild.Core.Targets
} }
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// Writes the specified kern. /// Writes the specified kern.
/// </summary> /// </summary>
/// <param name="kern">The kern.</param> /// <param name="kern">The kern.</param>
public override void Write(Kernel kern) public override void Write(Kernel kern)
{ {
base.Write(kern); base.Write(kern);
} }
/// <summary> /// <summary>
/// Cleans the specified kern. /// Cleans the specified kern.
/// </summary> /// </summary>
/// <param name="kern">The kern.</param> /// <param name="kern">The kern.</param>
public override void Clean(Kernel kern) public override void Clean(Kernel kern)
{ {
base.Clean(kern); base.Clean(kern);
} }
/// <summary> /// <summary>
/// Gets the name. /// Gets the name.
/// </summary> /// </summary>
/// <value>The name.</value> /// <value>The name.</value>
public override string Name public override string Name
{ {
get get
{ {
return "sharpdev2"; return "sharpdev2";
} }
} }
#endregion #endregion
} }
} }

664
Prebuild/src/Core/Targets/SharpDevelopTarget.cs
View File

@ -34,392 +34,392 @@ using Prebuild.Core.Utilities;
namespace Prebuild.Core.Targets namespace Prebuild.Core.Targets
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[Target("sharpdev")] [Target("sharpdev")]
public class SharpDevelopTarget : ITarget public class SharpDevelopTarget : ITarget
{ {
#region Fields #region Fields
private Kernel m_Kernel; private Kernel m_Kernel;
#endregion #endregion
#region Private Methods #region Private Methods
private static string PrependPath(string path) private static string PrependPath(string path)
{ {
string tmpPath = Helper.NormalizePath(path, '/'); string tmpPath = Helper.NormalizePath(path, '/');
Regex regex = new Regex(@"(\w):/(\w+)"); Regex regex = new Regex(@"(\w):/(\w+)");
Match match = regex.Match(tmpPath); Match match = regex.Match(tmpPath);
if(match.Success || tmpPath[0] == '.' || tmpPath[0] == '/') if(match.Success || tmpPath[0] == '.' || tmpPath[0] == '/')
{ {
tmpPath = Helper.NormalizePath(tmpPath); tmpPath = Helper.NormalizePath(tmpPath);
} }
else else
{ {
tmpPath = Helper.NormalizePath("./" + tmpPath); tmpPath = Helper.NormalizePath("./" + tmpPath);
} }
return tmpPath; return tmpPath;
} }
private static string BuildReference(SolutionNode solution, ReferenceNode refr) private static string BuildReference(SolutionNode solution, ReferenceNode refr)
{ {
string ret = "<Reference type=\""; string ret = "<Reference type=\"";
if(solution.ProjectsTable.ContainsKey(refr.Name)) if(solution.ProjectsTable.ContainsKey(refr.Name))
{ {
ret += "Project\" refto=\"" + refr.Name; ret += "Project\" refto=\"" + refr.Name;
ret += "\" localcopy=\"" + refr.LocalCopy.ToString() + "\" />"; ret += "\" localcopy=\"" + refr.LocalCopy.ToString() + "\" />";
} }
else else
{ {
ProjectNode project = (ProjectNode)refr.Parent; ProjectNode project = (ProjectNode)refr.Parent;
string fileRef = FindFileReference(refr.Name, project); string fileRef = FindFileReference(refr.Name, project);
if(refr.Path != null || fileRef != null) if(refr.Path != null || fileRef != null)
{ {
ret += "Assembly\" refto=\""; ret += "Assembly\" refto=\"";
string finalPath = (refr.Path != null) ? Helper.MakeFilePath(refr.Path, refr.Name, "dll") : fileRef; string finalPath = (refr.Path != null) ? Helper.MakeFilePath(refr.Path, refr.Name, "dll") : fileRef;
ret += finalPath; ret += finalPath;
ret += "\" localcopy=\"" + refr.LocalCopy.ToString() + "\" />"; ret += "\" localcopy=\"" + refr.LocalCopy.ToString() + "\" />";
return ret; return ret;
} }
ret += "Gac\" refto=\""; ret += "Gac\" refto=\"";
try try
{ {
//Assembly assem = Assembly.Load(refr.Name); //Assembly assem = Assembly.Load(refr.Name);
ret += refr.Name;// assem.FullName; ret += refr.Name;// assem.FullName;
} }
catch (System.NullReferenceException e) catch (System.NullReferenceException e)
{ {
e.ToString(); e.ToString();
ret += refr.Name; ret += refr.Name;
} }
ret += "\" localcopy=\"" + refr.LocalCopy.ToString() + "\" />"; ret += "\" localcopy=\"" + refr.LocalCopy.ToString() + "\" />";
} }
return ret; return ret;
} }
private static string FindFileReference(string refName, ProjectNode project) private static string FindFileReference(string refName, ProjectNode project)
{ {
foreach(ReferencePathNode refPath in project.ReferencePaths) foreach(ReferencePathNode refPath in project.ReferencePaths)
{ {
string fullPath = Helper.MakeFilePath(refPath.Path, refName, "dll"); string fullPath = Helper.MakeFilePath(refPath.Path, refName, "dll");
if(File.Exists(fullPath)) if(File.Exists(fullPath))
{ {
return fullPath; return fullPath;
} }
} }
return null; return null;
} }
/// <summary> /// <summary>
/// Gets the XML doc file. /// Gets the XML doc file.
/// </summary> /// </summary>
/// <param name="project">The project.</param> /// <param name="project">The project.</param>
/// <param name="conf">The conf.</param> /// <param name="conf">The conf.</param>
/// <returns></returns> /// <returns></returns>
public static string GenerateXmlDocFile(ProjectNode project, ConfigurationNode conf) public static string GenerateXmlDocFile(ProjectNode project, ConfigurationNode conf)
{ {
if( conf == null ) if( conf == null )
{ {
throw new ArgumentNullException("conf"); throw new ArgumentNullException("conf");
} }
if( project == null ) if( project == null )
{ {
throw new ArgumentNullException("project"); throw new ArgumentNullException("project");
} }
string docFile = (string)conf.Options["XmlDocFile"]; string docFile = (string)conf.Options["XmlDocFile"];
if(docFile != null && docFile.Length == 0)//default to assembly name if not specified if(docFile != null && docFile.Length == 0)//default to assembly name if not specified
{ {
return "False"; return "False";
} }
return "True"; return "True";
} }
private void WriteProject(SolutionNode solution, ProjectNode project) private void WriteProject(SolutionNode solution, ProjectNode project)
{ {
string csComp = "Csc"; string csComp = "Csc";
string netRuntime = "MsNet"; string netRuntime = "MsNet";
if(project.Runtime == ClrRuntime.Mono) if(project.Runtime == ClrRuntime.Mono)
{ {
csComp = "Mcs"; csComp = "Mcs";
netRuntime = "Mono"; netRuntime = "Mono";
} }
string projFile = Helper.MakeFilePath(project.FullPath, project.Name, "prjx"); string projFile = Helper.MakeFilePath(project.FullPath, project.Name, "prjx");
StreamWriter ss = new StreamWriter(projFile); StreamWriter ss = new StreamWriter(projFile);
m_Kernel.CurrentWorkingDirectory.Push(); m_Kernel.CurrentWorkingDirectory.Push();
Helper.SetCurrentDir(Path.GetDirectoryName(projFile)); Helper.SetCurrentDir(Path.GetDirectoryName(projFile));
using(ss) using(ss)
{ {
ss.WriteLine( ss.WriteLine(
"<Project name=\"{0}\" standardNamespace=\"{1}\" description=\"\" newfilesearch=\"None\" enableviewstate=\"True\" version=\"1.1\" projecttype=\"C#\">", "<Project name=\"{0}\" standardNamespace=\"{1}\" description=\"\" newfilesearch=\"None\" enableviewstate=\"True\" version=\"1.1\" projecttype=\"C#\">",
project.Name, project.Name,
project.RootNamespace project.RootNamespace
); );
ss.WriteLine(" <Contents>"); ss.WriteLine(" <Contents>");
foreach(string file in project.Files) foreach(string file in project.Files)
{ {
string buildAction = "Compile"; string buildAction = "Compile";
switch(project.Files.GetBuildAction(file)) switch(project.Files.GetBuildAction(file))
{ {
case BuildAction.None: case BuildAction.None:
buildAction = "Nothing"; buildAction = "Nothing";
break; break;
case BuildAction.Content: case BuildAction.Content:
buildAction = "Exclude"; buildAction = "Exclude";
break; break;
case BuildAction.EmbeddedResource: case BuildAction.EmbeddedResource:
buildAction = "EmbedAsResource"; buildAction = "EmbedAsResource";
break; break;
default: default:
buildAction = "Compile"; buildAction = "Compile";
break; break;
} }
// Sort of a hack, we try and resolve the path and make it relative, if we can. // Sort of a hack, we try and resolve the path and make it relative, if we can.
string filePath = PrependPath(file); string filePath = PrependPath(file);
ss.WriteLine(" <File name=\"{0}\" subtype=\"Code\" buildaction=\"{1}\" dependson=\"\" data=\"\" />", filePath, buildAction); ss.WriteLine(" <File name=\"{0}\" subtype=\"Code\" buildaction=\"{1}\" dependson=\"\" data=\"\" />", filePath, buildAction);
} }
ss.WriteLine(" </Contents>"); ss.WriteLine(" </Contents>");
ss.WriteLine(" <References>"); ss.WriteLine(" <References>");
foreach(ReferenceNode refr in project.References) foreach(ReferenceNode refr in project.References)
{ {
ss.WriteLine(" {0}", BuildReference(solution, refr)); ss.WriteLine(" {0}", BuildReference(solution, refr));
} }
ss.WriteLine(" </References>"); ss.WriteLine(" </References>");
ss.Write(" <DeploymentInformation"); ss.Write(" <DeploymentInformation");
ss.Write(" target=\"\""); ss.Write(" target=\"\"");
ss.Write(" script=\"\""); ss.Write(" script=\"\"");
ss.Write(" strategy=\"File\""); ss.Write(" strategy=\"File\"");
ss.WriteLine(" />"); ss.WriteLine(" />");
int count = 0; int count = 0;
ss.WriteLine(" <Configurations active=\"{0}\">", solution.ActiveConfig); ss.WriteLine(" <Configurations active=\"{0}\">", solution.ActiveConfig);
foreach(ConfigurationNode conf in project.Configurations) foreach(ConfigurationNode conf in project.Configurations)
{ {
ss.Write(" <Configuration"); ss.Write(" <Configuration");
ss.Write(" runwithwarnings=\"True\""); ss.Write(" runwithwarnings=\"True\"");
ss.Write(" name=\"{0}\"", conf.Name); ss.Write(" name=\"{0}\"", conf.Name);
ss.WriteLine(">"); ss.WriteLine(">");
ss.Write(" <CodeGeneration"); ss.Write(" <CodeGeneration");
ss.Write(" runtime=\"{0}\"", netRuntime); ss.Write(" runtime=\"{0}\"", netRuntime);
ss.Write(" compiler=\"{0}\"", csComp); ss.Write(" compiler=\"{0}\"", csComp);
ss.Write(" compilerversion=\"\""); ss.Write(" compilerversion=\"\"");
ss.Write(" warninglevel=\"{0}\"", conf.Options["WarningLevel"]); ss.Write(" warninglevel=\"{0}\"", conf.Options["WarningLevel"]);
ss.Write(" nowarn=\"{0}\"", conf.Options["SuppressWarnings"]); ss.Write(" nowarn=\"{0}\"", conf.Options["SuppressWarnings"]);
ss.Write(" includedebuginformation=\"{0}\"", conf.Options["DebugInformation"]); ss.Write(" includedebuginformation=\"{0}\"", conf.Options["DebugInformation"]);
ss.Write(" optimize=\"{0}\"", conf.Options["OptimizeCode"]); ss.Write(" optimize=\"{0}\"", conf.Options["OptimizeCode"]);
ss.Write(" unsafecodeallowed=\"{0}\"", conf.Options["AllowUnsafe"]); ss.Write(" unsafecodeallowed=\"{0}\"", conf.Options["AllowUnsafe"]);
ss.Write(" generateoverflowchecks=\"{0}\"", conf.Options["CheckUnderflowOverflow"]); ss.Write(" generateoverflowchecks=\"{0}\"", conf.Options["CheckUnderflowOverflow"]);
ss.Write(" mainclass=\"{0}\"", project.StartupObject); ss.Write(" mainclass=\"{0}\"", project.StartupObject);
ss.Write(" target=\"{0}\"", project.Type); ss.Write(" target=\"{0}\"", project.Type);
ss.Write(" definesymbols=\"{0}\"", conf.Options["CompilerDefines"]); ss.Write(" definesymbols=\"{0}\"", conf.Options["CompilerDefines"]);
ss.Write(" generatexmldocumentation=\"{0}\"", GenerateXmlDocFile(project, conf)); ss.Write(" generatexmldocumentation=\"{0}\"", GenerateXmlDocFile(project, conf));
ss.Write(" win32Icon=\"{0}\"", Helper.NormalizePath(".\\" + project.AppIcon)); ss.Write(" win32Icon=\"{0}\"", Helper.NormalizePath(".\\" + project.AppIcon));
ss.Write(" noconfig=\"{0}\"", "False"); ss.Write(" noconfig=\"{0}\"", "False");
ss.Write(" nostdlib=\"{0}\"", conf.Options["NoStdLib"]); ss.Write(" nostdlib=\"{0}\"", conf.Options["NoStdLib"]);
ss.WriteLine(" />"); ss.WriteLine(" />");
ss.Write(" <Execution"); ss.Write(" <Execution");
ss.Write(" commandlineparameters=\"\""); ss.Write(" commandlineparameters=\"\"");
ss.Write(" consolepause=\"True\""); ss.Write(" consolepause=\"True\"");
ss.WriteLine(" />"); ss.WriteLine(" />");
ss.Write(" <Output"); ss.Write(" <Output");
ss.Write(" directory=\".\\{0}\"", Helper.NormalizePath(conf.Options["OutputPath"].ToString())); ss.Write(" directory=\".\\{0}\"", Helper.NormalizePath(conf.Options["OutputPath"].ToString()));
ss.Write(" assembly=\"{0}\"", project.AssemblyName); ss.Write(" assembly=\"{0}\"", project.AssemblyName);
ss.Write(" executeScript=\"{0}\"", conf.Options["RunScript"]); ss.Write(" executeScript=\"{0}\"", conf.Options["RunScript"]);
if (conf.Options["PreBuildEvent"] != null && conf.Options["PreBuildEvent"].ToString().Length != 0) if (conf.Options["PreBuildEvent"] != null && conf.Options["PreBuildEvent"].ToString().Length != 0)
{ {
ss.Write(" executeBeforeBuild=\"{0}\"", Helper.NormalizePath(conf.Options["PreBuildEvent"].ToString())); ss.Write(" executeBeforeBuild=\"{0}\"", Helper.NormalizePath(conf.Options["PreBuildEvent"].ToString()));
} }
else else
{ {
ss.Write(" executeBeforeBuild=\"{0}\"", conf.Options["PreBuildEvent"]); ss.Write(" executeBeforeBuild=\"{0}\"", conf.Options["PreBuildEvent"]);
} }
if (conf.Options["PostBuildEvent"] != null && conf.Options["PostBuildEvent"].ToString().Length != 0) if (conf.Options["PostBuildEvent"] != null && conf.Options["PostBuildEvent"].ToString().Length != 0)
{ {
ss.Write(" executeAfterBuild=\"{0}\"", Helper.NormalizePath(conf.Options["PostBuildEvent"].ToString())); ss.Write(" executeAfterBuild=\"{0}\"", Helper.NormalizePath(conf.Options["PostBuildEvent"].ToString()));
} }
else else
{ {
ss.Write(" executeAfterBuild=\"{0}\"", conf.Options["PostBuildEvent"]); ss.Write(" executeAfterBuild=\"{0}\"", conf.Options["PostBuildEvent"]);
} }
ss.Write(" executeBeforeBuildArguments=\"{0}\"", conf.Options["PreBuildEventArgs"]); ss.Write(" executeBeforeBuildArguments=\"{0}\"", conf.Options["PreBuildEventArgs"]);
ss.Write(" executeAfterBuildArguments=\"{0}\"", conf.Options["PreBuildEventArgs"]); ss.Write(" executeAfterBuildArguments=\"{0}\"", conf.Options["PreBuildEventArgs"]);
ss.WriteLine(" />"); ss.WriteLine(" />");
ss.WriteLine(" </Configuration>"); ss.WriteLine(" </Configuration>");
count++; count++;
} }
ss.WriteLine(" </Configurations>"); ss.WriteLine(" </Configurations>");
ss.WriteLine("</Project>"); ss.WriteLine("</Project>");
} }
m_Kernel.CurrentWorkingDirectory.Pop(); m_Kernel.CurrentWorkingDirectory.Pop();
} }
private void WriteCombine(SolutionNode solution) private void WriteCombine(SolutionNode solution)
{ {
m_Kernel.Log.Write("Creating SharpDevelop combine and project files"); m_Kernel.Log.Write("Creating SharpDevelop combine and project files");
foreach(ProjectNode project in solution.Projects) foreach(ProjectNode project in solution.Projects)
{ {
if(m_Kernel.AllowProject(project.FilterGroups)) if(m_Kernel.AllowProject(project.FilterGroups))
{ {
m_Kernel.Log.Write("...Creating project: {0}", project.Name); m_Kernel.Log.Write("...Creating project: {0}", project.Name);
WriteProject(solution, project); WriteProject(solution, project);
} }
} }
m_Kernel.Log.Write(""); m_Kernel.Log.Write("");
string combFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "cmbx"); string combFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "cmbx");
StreamWriter ss = new StreamWriter(combFile); StreamWriter ss = new StreamWriter(combFile);
m_Kernel.CurrentWorkingDirectory.Push(); m_Kernel.CurrentWorkingDirectory.Push();
Helper.SetCurrentDir(Path.GetDirectoryName(combFile)); Helper.SetCurrentDir(Path.GetDirectoryName(combFile));
using(ss) using(ss)
{ {
ss.WriteLine("<Combine fileversion=\"1.0\" name=\"{0}\" description=\"\">", solution.Name); ss.WriteLine("<Combine fileversion=\"1.0\" name=\"{0}\" description=\"\">", solution.Name);
int count = 0; int count = 0;
foreach(ProjectNode project in solution.Projects) foreach(ProjectNode project in solution.Projects)
{ {
if(count == 0) if(count == 0)
ss.WriteLine(" <StartMode startupentry=\"{0}\" single=\"True\">", project.Name); ss.WriteLine(" <StartMode startupentry=\"{0}\" single=\"True\">", project.Name);
ss.WriteLine(" <Execute entry=\"{0}\" type=\"None\" />", project.Name); ss.WriteLine(" <Execute entry=\"{0}\" type=\"None\" />", project.Name);
count++; count++;
} }
ss.WriteLine(" </StartMode>"); ss.WriteLine(" </StartMode>");
ss.WriteLine(" <Entries>"); ss.WriteLine(" <Entries>");
foreach(ProjectNode project in solution.Projects) foreach(ProjectNode project in solution.Projects)
{ {
string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath); string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
ss.WriteLine(" <Entry filename=\"{0}\" />", ss.WriteLine(" <Entry filename=\"{0}\" />",
Helper.MakeFilePath(path, project.Name, "prjx")); Helper.MakeFilePath(path, project.Name, "prjx"));
} }
ss.WriteLine(" </Entries>"); ss.WriteLine(" </Entries>");
count = 0; count = 0;
foreach(ConfigurationNode conf in solution.Configurations) foreach(ConfigurationNode conf in solution.Configurations)
{ {
if(count == 0) if(count == 0)
{ {
ss.WriteLine(" <Configurations active=\"{0}\">", conf.Name); ss.WriteLine(" <Configurations active=\"{0}\">", conf.Name);
} }
ss.WriteLine(" <Configuration name=\"{0}\">", conf.Name); ss.WriteLine(" <Configuration name=\"{0}\">", conf.Name);
foreach(ProjectNode project in solution.Projects) foreach(ProjectNode project in solution.Projects)
{ {
ss.WriteLine(" <Entry name=\"{0}\" configurationname=\"{1}\" build=\"True\" />", project.Name, conf.Name); ss.WriteLine(" <Entry name=\"{0}\" configurationname=\"{1}\" build=\"True\" />", project.Name, conf.Name);
} }
ss.WriteLine(" </Configuration>"); ss.WriteLine(" </Configuration>");
count++; count++;
} }
ss.WriteLine(" </Configurations>"); ss.WriteLine(" </Configurations>");
ss.WriteLine("</Combine>"); ss.WriteLine("</Combine>");
} }
m_Kernel.CurrentWorkingDirectory.Pop(); m_Kernel.CurrentWorkingDirectory.Pop();
} }
private void CleanProject(ProjectNode project) private void CleanProject(ProjectNode project)
{ {
m_Kernel.Log.Write("...Cleaning project: {0}", project.Name); m_Kernel.Log.Write("...Cleaning project: {0}", project.Name);
string projectFile = Helper.MakeFilePath(project.FullPath, project.Name, "prjx"); string projectFile = Helper.MakeFilePath(project.FullPath, project.Name, "prjx");
Helper.DeleteIfExists(projectFile); Helper.DeleteIfExists(projectFile);
} }
private void CleanSolution(SolutionNode solution) private void CleanSolution(SolutionNode solution)
{ {
m_Kernel.Log.Write("Cleaning SharpDevelop combine and project files for", solution.Name); m_Kernel.Log.Write("Cleaning SharpDevelop combine and project files for", solution.Name);
string slnFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "cmbx"); string slnFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "cmbx");
Helper.DeleteIfExists(slnFile); Helper.DeleteIfExists(slnFile);
foreach(ProjectNode project in solution.Projects) foreach(ProjectNode project in solution.Projects)
{ {
CleanProject(project); CleanProject(project);
} }
m_Kernel.Log.Write(""); m_Kernel.Log.Write("");
} }
#endregion #endregion
#region ITarget Members #region ITarget Members
/// <summary> /// <summary>
/// Writes the specified kern. /// Writes the specified kern.
/// </summary> /// </summary>
/// <param name="kern">The kern.</param> /// <param name="kern">The kern.</param>
public void Write(Kernel kern) public void Write(Kernel kern)
{ {
if( kern == null ) if( kern == null )
{ {
throw new ArgumentNullException("kern"); throw new ArgumentNullException("kern");
} }
m_Kernel = kern; m_Kernel = kern;
foreach(SolutionNode solution in kern.Solutions) foreach(SolutionNode solution in kern.Solutions)
{ {
WriteCombine(solution); WriteCombine(solution);
} }
m_Kernel = null; m_Kernel = null;
} }
/// <summary> /// <summary>
/// Cleans the specified kern. /// Cleans the specified kern.
/// </summary> /// </summary>
/// <param name="kern">The kern.</param> /// <param name="kern">The kern.</param>
public virtual void Clean(Kernel kern) public virtual void Clean(Kernel kern)
{ {
if( kern == null ) if( kern == null )
{ {
throw new ArgumentNullException("kern"); throw new ArgumentNullException("kern");
} }
m_Kernel = kern; m_Kernel = kern;
foreach(SolutionNode sol in kern.Solutions) foreach(SolutionNode sol in kern.Solutions)
{ {
CleanSolution(sol); CleanSolution(sol);
} }
m_Kernel = null; m_Kernel = null;
} }
/// <summary> /// <summary>
/// Gets the name. /// Gets the name.
/// </summary> /// </summary>
/// <value>The name.</value> /// <value>The name.</value>
public string Name public string Name
{ {
get get
{ {
return "sharpdev"; return "sharpdev";
} }
} }
#endregion #endregion
} }
} }

356
Prebuild/src/Core/Targets/ToolInfo.cs
View File

@ -4,194 +4,194 @@ using System.Text;
namespace Prebuild.Core.Targets namespace Prebuild.Core.Targets
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public struct ToolInfo public struct ToolInfo
{ {
string name; string name;
string guid; string guid;
string fileExtension; string fileExtension;
string xmlTag; string xmlTag;
string importProject; string importProject;
/// <summary> /// <summary>
/// Gets or sets the name. /// Gets or sets the name.
/// </summary> /// </summary>
/// <value>The name.</value> /// <value>The name.</value>
public string Name public string Name
{ {
get get
{ {
return name; return name;
} }
set set
{ {
name = value; name = value;
} }
} }
/// <summary> /// <summary>
/// Gets or sets the GUID. /// Gets or sets the GUID.
/// </summary> /// </summary>
/// <value>The GUID.</value> /// <value>The GUID.</value>
public string Guid public string Guid
{ {
get get
{ {
return guid; return guid;
} }
set set
{ {
guid = value; guid = value;
} }
} }
/// <summary> /// <summary>
/// Gets or sets the file extension. /// Gets or sets the file extension.
/// </summary> /// </summary>
/// <value>The file extension.</value> /// <value>The file extension.</value>
public string FileExtension public string FileExtension
{ {
get get
{ {
return fileExtension; return fileExtension;
} }
set set
{ {
fileExtension = value; fileExtension = value;
} }
} }
public string LanguageExtension public string LanguageExtension
{ {
get get
{ {
switch (this.Name) switch (this.Name)
{ {
case "C#": case "C#":
return ".cs"; return ".cs";
case "VisualBasic": case "VisualBasic":
return ".vb"; return ".vb";
case "Boo": case "Boo":
return ".boo"; return ".boo";
default: default:
return ".cs"; return ".cs";
} }
} }
} }
/// <summary> /// <summary>
/// Gets or sets the XML tag. /// Gets or sets the XML tag.
/// </summary> /// </summary>
/// <value>The XML tag.</value> /// <value>The XML tag.</value>
public string XmlTag public string XmlTag
{ {
get get
{ {
return xmlTag; return xmlTag;
} }
set set
{ {
xmlTag = value; xmlTag = value;
} }
} }
/// <summary> /// <summary>
/// Gets or sets the import project property. /// Gets or sets the import project property.
/// </summary> /// </summary>
/// <value>The ImportProject tag.</value> /// <value>The ImportProject tag.</value>
public string ImportProject public string ImportProject
{ {
get get
{ {
return importProject; return importProject;
} }
set set
{ {
importProject = value; importProject = value;
} }
} }
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="ToolInfo"/> class. /// Initializes a new instance of the <see cref="ToolInfo"/> class.
/// </summary> /// </summary>
/// <param name="name">The name.</param> /// <param name="name">The name.</param>
/// <param name="guid">The GUID.</param> /// <param name="guid">The GUID.</param>
/// <param name="fileExtension">The file extension.</param> /// <param name="fileExtension">The file extension.</param>
/// <param name="xml">The XML.</param> /// <param name="xml">The XML.</param>
/// <param name="importProject">The import project.</param> /// <param name="importProject">The import project.</param>
public ToolInfo(string name, string guid, string fileExtension, string xml, string importProject) public ToolInfo(string name, string guid, string fileExtension, string xml, string importProject)
{ {
this.name = name; this.name = name;
this.guid = guid; this.guid = guid;
this.fileExtension = fileExtension; this.fileExtension = fileExtension;
this.xmlTag = xml; this.xmlTag = xml;
this.importProject = importProject; this.importProject = importProject;
} }
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="ToolInfo"/> class. /// Initializes a new instance of the <see cref="ToolInfo"/> class.
/// </summary> /// </summary>
/// <param name="name">The name.</param> /// <param name="name">The name.</param>
/// <param name="guid">The GUID.</param> /// <param name="guid">The GUID.</param>
/// <param name="fileExtension">The file extension.</param> /// <param name="fileExtension">The file extension.</param>
/// <param name="xml">The XML.</param> /// <param name="xml">The XML.</param>
public ToolInfo(string name, string guid, string fileExtension, string xml) public ToolInfo(string name, string guid, string fileExtension, string xml)
{ {
this.name = name; this.name = name;
this.guid = guid; this.guid = guid;
this.fileExtension = fileExtension; this.fileExtension = fileExtension;
this.xmlTag = xml; this.xmlTag = xml;
this.importProject = "$(MSBuildBinPath)\\Microsoft." + xml + ".Targets"; this.importProject = "$(MSBuildBinPath)\\Microsoft." + xml + ".Targets";
} }
/// <summary> /// <summary>
/// Equals operator /// Equals operator
/// </summary> /// </summary>
/// <param name="obj">ToolInfo to compare</param> /// <param name="obj">ToolInfo to compare</param>
/// <returns>true if toolInfos are equal</returns> /// <returns>true if toolInfos are equal</returns>
public override bool Equals(object obj) public override bool Equals(object obj)
{ {
if (obj == null) if (obj == null)
{ {
throw new ArgumentNullException("obj"); throw new ArgumentNullException("obj");
} }
if (obj.GetType() != typeof(ToolInfo)) if (obj.GetType() != typeof(ToolInfo))
return false; return false;
ToolInfo c = (ToolInfo)obj; ToolInfo c = (ToolInfo)obj;
return ((this.name == c.name) && (this.guid == c.guid) && (this.fileExtension == c.fileExtension) && (this.importProject == c.importProject)); return ((this.name == c.name) && (this.guid == c.guid) && (this.fileExtension == c.fileExtension) && (this.importProject == c.importProject));
} }
/// <summary> /// <summary>
/// Equals operator /// Equals operator
/// </summary> /// </summary>
/// <param name="c1">ToolInfo to compare</param> /// <param name="c1">ToolInfo to compare</param>
/// <param name="c2">ToolInfo to compare</param> /// <param name="c2">ToolInfo to compare</param>
/// <returns>True if toolInfos are equal</returns> /// <returns>True if toolInfos are equal</returns>
public static bool operator ==(ToolInfo c1, ToolInfo c2) public static bool operator ==(ToolInfo c1, ToolInfo c2)
{ {
return ((c1.name == c2.name) && (c1.guid == c2.guid) && (c1.fileExtension == c2.fileExtension) && (c1.importProject == c2.importProject) && (c1.xmlTag == c2.xmlTag)); return ((c1.name == c2.name) && (c1.guid == c2.guid) && (c1.fileExtension == c2.fileExtension) && (c1.importProject == c2.importProject) && (c1.xmlTag == c2.xmlTag));
} }
/// <summary> /// <summary>
/// Not equals operator /// Not equals operator
/// </summary> /// </summary>
/// <param name="c1">ToolInfo to compare</param> /// <param name="c1">ToolInfo to compare</param>
/// <param name="c2">ToolInfo to compare</param> /// <param name="c2">ToolInfo to compare</param>
/// <returns>True if toolInfos are not equal</returns> /// <returns>True if toolInfos are not equal</returns>
public static bool operator !=(ToolInfo c1, ToolInfo c2) public static bool operator !=(ToolInfo c1, ToolInfo c2)
{ {
return !(c1 == c2); return !(c1 == c2);
} }
/// <summary> /// <summary>
/// Hash Code /// Hash Code
/// </summary> /// </summary>
/// <returns>Hash code</returns> /// <returns>Hash code</returns>
public override int GetHashCode() public override int GetHashCode()
{ {
return name.GetHashCode() ^ guid.GetHashCode() ^ this.fileExtension.GetHashCode() ^ this.importProject.GetHashCode() ^ this.xmlTag.GetHashCode(); return name.GetHashCode() ^ guid.GetHashCode() ^ this.fileExtension.GetHashCode() ^ this.importProject.GetHashCode() ^ this.xmlTag.GetHashCode();
} }
} }
} }

96
Prebuild/src/Core/Targets/VS2002Target.cs
View File

@ -29,59 +29,59 @@ using Prebuild.Core.Attributes;
namespace Prebuild.Core.Targets namespace Prebuild.Core.Targets
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[Target("vs2002")] [Target("vs2002")]
public class VS2002Target : VS2003Target public class VS2002Target : VS2003Target
{ {
#region Private Methods #region Private Methods
private void SetVS2002() private void SetVS2002()
{ {
this.SolutionVersion = "7.00"; this.SolutionVersion = "7.00";
this.ProductVersion = "7.0.9254"; this.ProductVersion = "7.0.9254";
this.SchemaVersion = "1.0"; this.SchemaVersion = "1.0";
this.VersionName = "2002"; this.VersionName = "2002";
this.Version = VSVersion.VS70; this.Version = VSVersion.VS70;
} }
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// Writes the specified kern. /// Writes the specified kern.
/// </summary> /// </summary>
/// <param name="kern">The kern.</param> /// <param name="kern">The kern.</param>
public override void Write(Kernel kern) public override void Write(Kernel kern)
{ {
SetVS2002(); SetVS2002();
base.Write(kern); base.Write(kern);
} }
/// <summary> /// <summary>
/// Cleans the specified kern. /// Cleans the specified kern.
/// </summary> /// </summary>
/// <param name="kern">The kern.</param> /// <param name="kern">The kern.</param>
public override void Clean(Kernel kern) public override void Clean(Kernel kern)
{ {
SetVS2002(); SetVS2002();
base.Clean(kern); base.Clean(kern);
} }
/// <summary> /// <summary>
/// Gets the name. /// Gets the name.
/// </summary> /// </summary>
/// <value>The name.</value> /// <value>The name.</value>
public override string Name public override string Name
{ {
get get
{ {
return "vs2002"; return "vs2002";
} }
} }
#endregion #endregion
} }
} }

1112
Prebuild/src/Core/Targets/VS2003Target.cs
View File

File diff suppressed because it is too large Load Diff

180
Prebuild/src/Core/Targets/VS2008Target.cs
View File

@ -11,86 +11,86 @@ using System.CodeDom.Compiler;
namespace Prebuild.Core.Targets namespace Prebuild.Core.Targets
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[Target("vs2008")] [Target("vs2008")]
public class VS2008Target : VSGenericTarget public class VS2008Target : VSGenericTarget
{ {
#region Fields #region Fields
string solutionVersion = "10.00"; string solutionVersion = "10.00";
string productVersion = "9.0.21022"; string productVersion = "9.0.21022";
string schemaVersion = "2.0"; string schemaVersion = "2.0";
string versionName = "Visual Studio 2008"; string versionName = "Visual Studio 2008";
string name = "vs2008"; string name = "vs2008";
VSVersion version = VSVersion.VS90; VSVersion version = VSVersion.VS90;
/// <summary> /// <summary>
/// Gets or sets the solution version. /// Gets or sets the solution version.
/// </summary> /// </summary>
/// <value>The solution version.</value> /// <value>The solution version.</value>
public override string SolutionVersion public override string SolutionVersion
{ {
get get
{ {
return solutionVersion; return solutionVersion;
} }
} }
/// <summary> /// <summary>
/// Gets or sets the product version. /// Gets or sets the product version.
/// </summary> /// </summary>
/// <value>The product version.</value> /// <value>The product version.</value>
public override string ProductVersion public override string ProductVersion
{ {
get get
{ {
return productVersion; return productVersion;
} }
} }
/// <summary> /// <summary>
/// Gets or sets the schema version. /// Gets or sets the schema version.
/// </summary> /// </summary>
/// <value>The schema version.</value> /// <value>The schema version.</value>
public override string SchemaVersion public override string SchemaVersion
{ {
get get
{ {
return schemaVersion; return schemaVersion;
} }
} }
/// <summary> /// <summary>
/// Gets or sets the name of the version. /// Gets or sets the name of the version.
/// </summary> /// </summary>
/// <value>The name of the version.</value> /// <value>The name of the version.</value>
public override string VersionName public override string VersionName
{ {
get get
{ {
return versionName; return versionName;
} }
} }
/// <summary> /// <summary>
/// Gets or sets the version. /// Gets or sets the version.
/// </summary> /// </summary>
/// <value>The version.</value> /// <value>The version.</value>
public override VSVersion Version public override VSVersion Version
{ {
get get
{ {
return version; return version;
} }
} }
/// <summary> /// <summary>
/// Gets the name. /// Gets the name.
/// </summary> /// </summary>
/// <value>The name.</value> /// <value>The name.</value>
public override string Name public override string Name
{ {
get get
{ {
return name; return name;
} }
} }
protected override string GetToolsVersionXml(FrameworkVersion frameworkVersion) protected override string GetToolsVersionXml(FrameworkVersion frameworkVersion)
{ {
@ -110,18 +110,18 @@ namespace Prebuild.Core.Targets
get { return "# Visual Studio 2008"; } get { return "# Visual Studio 2008"; }
} }
#endregion #endregion
#region Constructors #region Constructors
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="VS2005Target"/> class. /// Initializes a new instance of the <see cref="VS2005Target"/> class.
/// </summary> /// </summary>
public VS2008Target() public VS2008Target()
: base() : base()
{ {
} }
#endregion #endregion
} }
} }

186
Prebuild/src/Core/Targets/VS2010Target.cs
View File

@ -11,96 +11,96 @@ using System.CodeDom.Compiler;
namespace Prebuild.Core.Targets namespace Prebuild.Core.Targets
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[Target("vs2010")] [Target("vs2010")]
public class VS2010Target : VSGenericTarget public class VS2010Target : VSGenericTarget
{ {
#region Fields #region Fields
string solutionVersion = "11.00"; string solutionVersion = "11.00";
string productVersion = "9.0.30729"; string productVersion = "9.0.30729";
string schemaVersion = "2.0"; string schemaVersion = "2.0";
string versionName = "Visual Studio 2010"; string versionName = "Visual Studio 2010";
string name = "vs2010"; string name = "vs2010";
VSVersion version = VSVersion.VS10; VSVersion version = VSVersion.VS10;
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// Gets or sets the solution version. /// Gets or sets the solution version.
/// </summary> /// </summary>
/// <value>The solution version.</value> /// <value>The solution version.</value>
public override string SolutionVersion public override string SolutionVersion
{ {
get get
{ {
return solutionVersion; return solutionVersion;
} }
} }
/// <summary> /// <summary>
/// Gets or sets the product version. /// Gets or sets the product version.
/// </summary> /// </summary>
/// <value>The product version.</value> /// <value>The product version.</value>
public override string ProductVersion public override string ProductVersion
{ {
get get
{ {
return productVersion; return productVersion;
} }
} }
/// <summary> /// <summary>
/// Gets or sets the schema version. /// Gets or sets the schema version.
/// </summary> /// </summary>
/// <value>The schema version.</value> /// <value>The schema version.</value>
public override string SchemaVersion public override string SchemaVersion
{ {
get get
{ {
return schemaVersion; return schemaVersion;
} }
} }
/// <summary> /// <summary>
/// Gets or sets the name of the version. /// Gets or sets the name of the version.
/// </summary> /// </summary>
/// <value>The name of the version.</value> /// <value>The name of the version.</value>
public override string VersionName public override string VersionName
{ {
get get
{ {
return versionName; return versionName;
} }
} }
/// <summary> /// <summary>
/// Gets or sets the version. /// Gets or sets the version.
/// </summary> /// </summary>
/// <value>The version.</value> /// <value>The version.</value>
public override VSVersion Version public override VSVersion Version
{ {
get get
{ {
return version; return version;
} }
} }
/// <summary> /// <summary>
/// Gets the name. /// Gets the name.
/// </summary> /// </summary>
/// <value>The name.</value> /// <value>The name.</value>
public override string Name public override string Name
{ {
get get
{ {
return name; return name;
} }
} }
protected override string GetToolsVersionXml(FrameworkVersion frameworkVersion) protected override string GetToolsVersionXml(FrameworkVersion frameworkVersion)
{ {
@ -110,7 +110,7 @@ namespace Prebuild.Core.Targets
case FrameworkVersion.v4_5: case FrameworkVersion.v4_5:
case FrameworkVersion.v4_0: case FrameworkVersion.v4_0:
case FrameworkVersion.v3_5: case FrameworkVersion.v3_5:
return "ToolsVersion=\"4.0\""; return "ToolsVersion=\"4.0\"";
case FrameworkVersion.v3_0: case FrameworkVersion.v3_0:
return "ToolsVersion=\"3.0\""; return "ToolsVersion=\"3.0\"";
default: default:
@ -123,18 +123,18 @@ namespace Prebuild.Core.Targets
get { return "# Visual Studio 2010"; } get { return "# Visual Studio 2010"; }
} }
#endregion #endregion
#region Constructors #region Constructors
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="VS2005Target"/> class. /// Initializes a new instance of the <see cref="VS2005Target"/> class.
/// </summary> /// </summary>
public VS2010Target() public VS2010Target()
: base() : base()
{ {
} }
#endregion #endregion
} }
} }

1654
Prebuild/src/Core/Targets/VSGenericTarget.cs
View File

File diff suppressed because it is too large Load Diff

61
Prebuild/src/Core/Targets/VSVersion.cs
View File

@ -25,30 +25,43 @@ IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY O
namespace Prebuild.Core.Targets namespace Prebuild.Core.Targets
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public enum VSVersion public enum VSVersion
{ {
/// <summary>
/// Visual Studio 2002
/// </summary>
VS70,
/// <summary>
/// Visual Studio 2003
/// </summary>
VS71,
/// <summary>
/// Visual Studio 2005
/// </summary>
VS80,
/// <summary>
/// Visual Studio 2008
/// </summary>
VS90,
/// <summary>
/// Visual Studio 2010
/// </summary>
VS10,
/// <summary>
/// Visual Studio 2012
/// </summary>
VS11,
/// <summary>
/// Visual Studio 2013
/// </summary>
VS12,
/// <summary> /// <summary>
/// Visual Studio 2002 /// Visual Studio 2015
/// </summary> /// </summary>
VS70, VS15
/// <summary>
/// Visual Studio 2003 }
/// </summary>
VS71,
/// <summary>
/// Visual Studio 2005
/// </summary>
VS80,
/// <summary>
/// Visual Studio 2008
/// </summary>
VS90,
/// <summary>
/// Visual Studio 2010
/// </summary>
VS10
}
} }

70
Prebuild/src/Core/UnknownLanguageException.cs
View File

@ -22,42 +22,42 @@ using System.Runtime.Serialization;
namespace Prebuild.Core namespace Prebuild.Core
{ {
/// <summary> /// <summary>
/// </summary> /// </summary>
[Serializable()] [Serializable()]
public class UnknownLanguageException : Exception public class UnknownLanguageException : Exception
{ {
/// <summary> /// <summary>
/// Basic exception. /// Basic exception.
/// </summary> /// </summary>
public UnknownLanguageException() public UnknownLanguageException()
{ {
} }
/// <summary> /// <summary>
/// Exception with specified string /// Exception with specified string
/// </summary> /// </summary>
/// <param name="message">Exception message</param> /// <param name="message">Exception message</param>
public UnknownLanguageException(string message): base(message) public UnknownLanguageException(string message): base(message)
{ {
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
/// <param name="message"></param> /// <param name="message"></param>
/// <param name="exception"></param> /// <param name="exception"></param>
public UnknownLanguageException(string message, Exception exception) : base(message, exception) public UnknownLanguageException(string message, Exception exception) : base(message, exception)
{ {
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
/// <param name="info"></param> /// <param name="info"></param>
/// <param name="context"></param> /// <param name="context"></param>
protected UnknownLanguageException(SerializationInfo info, StreamingContext context) : base( info, context ) protected UnknownLanguageException(SerializationInfo info, StreamingContext context) : base( info, context )
{ {
} }
} }
} }

190
Prebuild/src/Core/Utilities/CommandLineCollection.cs
View File

@ -28,125 +28,125 @@ using System.Collections.Generic;
namespace Prebuild.Core.Utilities namespace Prebuild.Core.Utilities
{ {
/// <summary> /// <summary>
/// The CommandLine class parses and interprets the command-line arguments passed to /// The CommandLine class parses and interprets the command-line arguments passed to
/// prebuild. /// prebuild.
/// </summary> /// </summary>
public class CommandLineCollection : IEnumerable<KeyValuePair<string, string>> public class CommandLineCollection : IEnumerable<KeyValuePair<string, string>>
{ {
#region Fields #region Fields
// The raw OS arguments // The raw OS arguments
private readonly string[] m_RawArgs; private readonly string[] m_RawArgs;
// Command-line argument storage // Command-line argument storage
private readonly Dictionary<string, string> m_Arguments = new Dictionary<string, string>(); private readonly Dictionary<string, string> m_Arguments = new Dictionary<string, string>();
#endregion #endregion
#region Constructors #region Constructors
/// <summary> /// <summary>
/// Create a new CommandLine instance and set some internal variables. /// Create a new CommandLine instance and set some internal variables.
/// </summary> /// </summary>
public CommandLineCollection(string[] args) public CommandLineCollection(string[] args)
{ {
m_RawArgs = args; m_RawArgs = args;
Parse(); Parse();
} }
#endregion #endregion
#region Private Methods #region Private Methods
private void Parse() private void Parse()
{ {
if(m_RawArgs.Length < 1) if(m_RawArgs.Length < 1)
return; return;
int idx = 0; int idx = 0;
string lastArg = null; string lastArg = null;
while(idx <m_RawArgs.Length) while(idx <m_RawArgs.Length)
{ {
string arg = m_RawArgs[idx]; string arg = m_RawArgs[idx];
if(arg.Length > 2 && arg[0] == '/') if(arg.Length > 2 && arg[0] == '/')
{ {
arg = arg.Substring(1); arg = arg.Substring(1);
lastArg = arg; lastArg = arg;
m_Arguments[arg] = ""; m_Arguments[arg] = "";
} }
else else
{ {
if(lastArg != null) if(lastArg != null)
{ {
m_Arguments[lastArg] = arg; m_Arguments[lastArg] = arg;
lastArg = null; lastArg = null;
} }
} }
idx++; idx++;
} }
} }
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// Wases the passed. /// Wases the passed.
/// </summary> /// </summary>
/// <param name="arg">The arg.</param> /// <param name="arg">The arg.</param>
/// <returns></returns> /// <returns></returns>
public bool WasPassed(string arg) public bool WasPassed(string arg)
{ {
return (m_Arguments.ContainsKey(arg)); return (m_Arguments.ContainsKey(arg));
} }
#endregion #endregion
#region Properties #region Properties
/// <summary> /// <summary>
/// Gets the parameter associated with the command line option /// Gets the parameter associated with the command line option
/// </summary> /// </summary>
/// <remarks>Returns null if option was not specified, /// <remarks>Returns null if option was not specified,
/// null string if no parameter was specified, and the value if a parameter was specified</remarks> /// null string if no parameter was specified, and the value if a parameter was specified</remarks>
public string this[string index] public string this[string index]
{ {
get get
{ {
if(m_Arguments.ContainsKey(index)) if(m_Arguments.ContainsKey(index))
{ {
return (m_Arguments[index]); return (m_Arguments[index]);
} }
return null; return null;
} }
} }
#endregion #endregion
#region IEnumerable Members #region IEnumerable Members
/// <summary> /// <summary>
/// Returns an enumerator that can iterate through a collection. /// Returns an enumerator that can iterate through a collection.
/// </summary> /// </summary>
/// <returns> /// <returns>
/// An <see cref="T:System.Collections.IDictionaryEnumerator"/> /// An <see cref="T:System.Collections.IDictionaryEnumerator"/>
/// that can be used to iterate through the collection. /// that can be used to iterate through the collection.
/// </returns> /// </returns>
public IEnumerator<KeyValuePair<string, string>> GetEnumerator() public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
{ {
return m_Arguments.GetEnumerator(); return m_Arguments.GetEnumerator();
} }
IEnumerator IEnumerable.GetEnumerator() IEnumerator IEnumerable.GetEnumerator()
{ {
return GetEnumerator(); return GetEnumerator();
} }
#endregion #endregion
} }
} }

60
Prebuild/src/Core/Utilities/CurrentDirectory.cs
View File

@ -28,41 +28,41 @@ using System.Collections.Generic;
namespace Prebuild.Core.Utilities namespace Prebuild.Core.Utilities
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public class CurrentDirectory public class CurrentDirectory
{ {
#region Fields #region Fields
private readonly Stack<string> m_Stack = new Stack<string>(); private readonly Stack<string> m_Stack = new Stack<string>();
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// Pushes this instance. /// Pushes this instance.
/// </summary> /// </summary>
public void Push() public void Push()
{ {
m_Stack.Push(Environment.CurrentDirectory); m_Stack.Push(Environment.CurrentDirectory);
} }
/// <summary> /// <summary>
/// Pops this instance. /// Pops this instance.
/// </summary> /// </summary>
public void Pop() public void Pop()
{ {
if(m_Stack.Count < 1) if(m_Stack.Count < 1)
{ {
return; return;
} }
string cwd = m_Stack.Pop(); string cwd = m_Stack.Pop();
Helper.SetCurrentDir(cwd); Helper.SetCurrentDir(cwd);
} }
#endregion #endregion
} }
} }

912
Prebuild/src/Core/Utilities/Helper.cs
View File

@ -35,541 +35,541 @@ using Prebuild.Core.Nodes;
namespace Prebuild.Core.Utilities namespace Prebuild.Core.Utilities
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public class Helper public class Helper
{ {
#region Fields #region Fields
static bool checkForOSVariables; static bool checkForOSVariables;
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public static bool CheckForOSVariables public static bool CheckForOSVariables
{ {
get get
{ {
return checkForOSVariables; return checkForOSVariables;
} }
set set
{ {
checkForOSVariables = value; checkForOSVariables = value;
} }
} }
#endregion #endregion
#region Public Methods #region Public Methods
#region String Parsing #region String Parsing
public delegate string StringLookup(string key); public delegate string StringLookup(string key);
/// <summary> /// <summary>
/// Gets a collection of StringLocationPair objects that represent the matches /// Gets a collection of StringLocationPair objects that represent the matches
/// </summary> /// </summary>
/// <param name="target">The target.</param> /// <param name="target">The target.</param>
/// <param name="beforeGroup">The before group.</param> /// <param name="beforeGroup">The before group.</param>
/// <param name="afterGroup">The after group.</param> /// <param name="afterGroup">The after group.</param>
/// <param name="includeDelimitersInSubstrings">if set to <c>true</c> [include delimiters in substrings].</param> /// <param name="includeDelimitersInSubstrings">if set to <c>true</c> [include delimiters in substrings].</param>
/// <returns></returns> /// <returns></returns>
public static StringCollection FindGroups(string target, string beforeGroup, string afterGroup, bool includeDelimitersInSubstrings) public static StringCollection FindGroups(string target, string beforeGroup, string afterGroup, bool includeDelimitersInSubstrings)
{ {
if( beforeGroup == null ) if( beforeGroup == null )
{ {
throw new ArgumentNullException("beforeGroup"); throw new ArgumentNullException("beforeGroup");
} }
if( afterGroup == null ) if( afterGroup == null )
{ {
throw new ArgumentNullException("afterGroup"); throw new ArgumentNullException("afterGroup");
} }
StringCollection results = new StringCollection(); StringCollection results = new StringCollection();
if(target == null || target.Length == 0) if(target == null || target.Length == 0)
{ {
return results; return results;
} }
int beforeMod = 0; int beforeMod = 0;
int afterMod = 0; int afterMod = 0;
if(includeDelimitersInSubstrings) if(includeDelimitersInSubstrings)
{ {
//be sure to not exlude the delims //be sure to not exlude the delims
beforeMod = beforeGroup.Length; beforeMod = beforeGroup.Length;
afterMod = afterGroup.Length; afterMod = afterGroup.Length;
} }
int startIndex = 0; int startIndex = 0;
while((startIndex = target.IndexOf(beforeGroup,startIndex)) != -1) { while((startIndex = target.IndexOf(beforeGroup,startIndex)) != -1) {
int endIndex = target.IndexOf(afterGroup,startIndex);//the index of the char after it int endIndex = target.IndexOf(afterGroup,startIndex);//the index of the char after it
if(endIndex == -1) if(endIndex == -1)
{ {
break; break;
} }
int length = endIndex - startIndex - beforeGroup.Length;//move to the first char in the string int length = endIndex - startIndex - beforeGroup.Length;//move to the first char in the string
string substring = substring = target.Substring(startIndex + beforeGroup.Length - beforeMod, string substring = target.Substring(startIndex + beforeGroup.Length - beforeMod,
length - afterMod); length - afterMod);
results.Add(substring); results.Add(substring);
//results.Add(new StringLocationPair(substring,startIndex)); //results.Add(new StringLocationPair(substring,startIndex));
startIndex = endIndex + 1; startIndex = endIndex + 1;
//the Interpolate*() methods will not work if expressions are expandded inside expression due to an optimization //the Interpolate*() methods will not work if expressions are expandded inside expression due to an optimization
//so start after endIndex //so start after endIndex
} }
return results; return results;
} }
/// <summary> /// <summary>
/// Replaces the groups. /// Replaces the groups.
/// </summary> /// </summary>
/// <param name="target">The target.</param> /// <param name="target">The target.</param>
/// <param name="beforeGroup">The before group.</param> /// <param name="beforeGroup">The before group.</param>
/// <param name="afterGroup">The after group.</param> /// <param name="afterGroup">The after group.</param>
/// <param name="lookup">The lookup.</param> /// <param name="lookup">The lookup.</param>
/// <returns></returns> /// <returns></returns>
public static string ReplaceGroups(string target, string beforeGroup, string afterGroup, StringLookup lookup) { public static string ReplaceGroups(string target, string beforeGroup, string afterGroup, StringLookup lookup) {
if( target == null ) if( target == null )
{ {
throw new ArgumentNullException("target"); throw new ArgumentNullException("target");
} }
//int targetLength = target.Length; //int targetLength = target.Length;
StringCollection strings = FindGroups(target,beforeGroup,afterGroup,false); StringCollection strings = FindGroups(target,beforeGroup,afterGroup,false);
if( lookup == null ) if( lookup == null )
{ {
throw new ArgumentNullException("lookup"); throw new ArgumentNullException("lookup");
} }
foreach(string substring in strings) foreach(string substring in strings)
{ {
target = target.Replace(beforeGroup + substring + afterGroup, lookup(substring) ); target = target.Replace(beforeGroup + substring + afterGroup, lookup(substring) );
} }
return target; return target;
} }
/// <summary> /// <summary>
/// Replaces ${var} statements in a string with the corresonding values as detirmined by the lookup delegate /// Replaces ${var} statements in a string with the corresonding values as detirmined by the lookup delegate
/// </summary> /// </summary>
/// <param name="target">The target.</param> /// <param name="target">The target.</param>
/// <param name="lookup">The lookup.</param> /// <param name="lookup">The lookup.</param>
/// <returns></returns> /// <returns></returns>
public static string InterpolateForVariables(string target, StringLookup lookup) public static string InterpolateForVariables(string target, StringLookup lookup)
{ {
return ReplaceGroups(target, "${" , "}" , lookup); return ReplaceGroups(target, "${" , "}" , lookup);
} }
/// <summary> /// <summary>
/// Replaces ${var} statements in a string with the corresonding environment variable with name var /// Replaces ${var} statements in a string with the corresonding environment variable with name var
/// </summary> /// </summary>
/// <param name="target"></param> /// <param name="target"></param>
/// <returns></returns> /// <returns></returns>
public static string InterpolateForEnvironmentVariables(string target) public static string InterpolateForEnvironmentVariables(string target)
{ {
return InterpolateForVariables(target, new StringLookup(Environment.GetEnvironmentVariable)); return InterpolateForVariables(target, new StringLookup(Environment.GetEnvironmentVariable));
} }
#endregion #endregion
/// <summary> /// <summary>
/// Translates the value. /// Translates the value.
/// </summary> /// </summary>
/// <param name="translateType">Type of the translate.</param> /// <param name="translateType">Type of the translate.</param>
/// <param name="translationItem">The translation item.</param> /// <param name="translationItem">The translation item.</param>
/// <returns></returns> /// <returns></returns>
public static object TranslateValue(Type translateType, string translationItem) public static object TranslateValue(Type translateType, string translationItem)
{ {
if(translationItem == null) if(translationItem == null)
{ {
return null; return null;
} }
try try
{ {
string lowerVal = translationItem.ToLower(); string lowerVal = translationItem.ToLower();
if(translateType == typeof(bool)) if(translateType == typeof(bool))
{ {
return (lowerVal == "true" || lowerVal == "1" || lowerVal == "y" || lowerVal == "yes" || lowerVal == "on"); return (lowerVal == "true" || lowerVal == "1" || lowerVal == "y" || lowerVal == "yes" || lowerVal == "on");
} }
else if(translateType == typeof(int)) else if(translateType == typeof(int))
{ {
return (Int32.Parse(translationItem)); return (Int32.Parse(translationItem));
} }
else else
{ {
return translationItem; return translationItem;
} }
} }
catch(FormatException) catch(FormatException)
{ {
return null; return null;
} }
} }
/// <summary> /// <summary>
/// Deletes if exists. /// Deletes if exists.
/// </summary> /// </summary>
/// <param name="file">The file.</param> /// <param name="file">The file.</param>
/// <returns></returns> /// <returns></returns>
public static bool DeleteIfExists(string file) public static bool DeleteIfExists(string file)
{ {
string resFile = null; string resFile = null;
try try
{ {
resFile = ResolvePath(file); resFile = ResolvePath(file);
} }
catch(ArgumentException) catch(ArgumentException)
{ {
return false; return false;
} }
if(!File.Exists(resFile)) if(!File.Exists(resFile))
{ {
return false; return false;
} }
File.Delete(resFile); File.Delete(resFile);
return true; return true;
} }
static readonly char seperator = Path.DirectorySeparatorChar; static readonly char seperator = Path.DirectorySeparatorChar;
// This little gem was taken from the NeL source, thanks guys! // This little gem was taken from the NeL source, thanks guys!
/// <summary> /// <summary>
/// Makes a relative path /// Makes a relative path
/// </summary> /// </summary>
/// <param name="startPath">Path to start from</param> /// <param name="startPath">Path to start from</param>
/// <param name="endPath">Path to end at</param> /// <param name="endPath">Path to end at</param>
/// <returns>Path that will get from startPath to endPath</returns> /// <returns>Path that will get from startPath to endPath</returns>
public static string MakePathRelativeTo(string startPath, string endPath) public static string MakePathRelativeTo(string startPath, string endPath)
{ {
string tmp = NormalizePath(startPath, seperator); string tmp = NormalizePath(startPath, seperator);
string src = NormalizePath(endPath, seperator); string src = NormalizePath(endPath, seperator);
string prefix = ""; string prefix = "";
while(true) while(true)
{ {
if((String.Compare(tmp, 0, src, 0, tmp.Length) == 0)) if((String.Compare(tmp, 0, src, 0, tmp.Length) == 0))
{ {
string ret; string ret;
int size = tmp.Length; int size = tmp.Length;
if(size == src.Length) if(size == src.Length)
{ {
return "./"; return "./";
} }
if((src.Length > tmp.Length) && src[tmp.Length - 1] != seperator) if((src.Length > tmp.Length) && src[tmp.Length - 1] != seperator)
{ {
} }
else else
{ {
ret = prefix + endPath.Substring(size, endPath.Length - size); ret = prefix + endPath.Substring(size, endPath.Length - size);
ret = ret.Trim(); ret = ret.Trim();
if(ret[0] == seperator) if(ret[0] == seperator)
{ {
ret = "." + ret; ret = "." + ret;
} }
return NormalizePath(ret); return NormalizePath(ret);
} }
} }
if(tmp.Length < 2) if(tmp.Length < 2)
{ {
break; break;
} }
int lastPos = tmp.LastIndexOf(seperator, tmp.Length - 2); int lastPos = tmp.LastIndexOf(seperator, tmp.Length - 2);
int prevPos = tmp.IndexOf(seperator); int prevPos = tmp.IndexOf(seperator);
if((lastPos == prevPos) || (lastPos == -1)) if((lastPos == prevPos) || (lastPos == -1))
{ {
break; break;
} }
tmp = tmp.Substring(0, lastPos + 1); tmp = tmp.Substring(0, lastPos + 1);
prefix += ".." + seperator.ToString(); prefix += ".." + seperator.ToString();
} }
return endPath; return endPath;
} }
/// <summary> /// <summary>
/// Resolves the path. /// Resolves the path.
/// </summary> /// </summary>
/// <param name="path">The path.</param> /// <param name="path">The path.</param>
/// <returns></returns> /// <returns></returns>
public static string ResolvePath(string path) public static string ResolvePath(string path)
{ {
string tmpPath = NormalizePath(path); string tmpPath = NormalizePath(path);
if(tmpPath.Length < 1) if(tmpPath.Length < 1)
{ {
tmpPath = "."; tmpPath = ".";
} }
tmpPath = Path.GetFullPath(tmpPath); tmpPath = Path.GetFullPath(tmpPath);
if(!File.Exists(tmpPath) && !Directory.Exists(tmpPath)) if(!File.Exists(tmpPath) && !Directory.Exists(tmpPath))
{ {
throw new ArgumentException("Path could not be resolved: " + tmpPath); throw new ArgumentException("Path could not be resolved: " + tmpPath);
} }
return tmpPath; return tmpPath;
} }
/// <summary> /// <summary>
/// Normalizes the path. /// Normalizes the path.
/// </summary> /// </summary>
/// <param name="path">The path.</param> /// <param name="path">The path.</param>
/// <param name="separatorCharacter">The separator character.</param> /// <param name="separatorCharacter">The separator character.</param>
/// <returns></returns> /// <returns></returns>
public static string NormalizePath(string path, char separatorCharacter) public static string NormalizePath(string path, char separatorCharacter)
{ {
if(path == null || path == "" || path.Length < 1) if(path == null || path == "" || path.Length < 1)
{ {
return ""; return "";
} }
string tmpPath = path.Replace('\\', '/'); string tmpPath = path.Replace('\\', '/');
tmpPath = tmpPath.Replace('/', separatorCharacter); tmpPath = tmpPath.Replace('/', separatorCharacter);
return tmpPath; return tmpPath;
} }
/// <summary> /// <summary>
/// Normalizes the path. /// Normalizes the path.
/// </summary> /// </summary>
/// <param name="path">The path.</param> /// <param name="path">The path.</param>
/// <returns></returns> /// <returns></returns>
public static string NormalizePath(string path) public static string NormalizePath(string path)
{ {
return NormalizePath(path, Path.DirectorySeparatorChar); return NormalizePath(path, Path.DirectorySeparatorChar);
} }
/// <summary> /// <summary>
/// Ends the path. /// Ends the path.
/// </summary> /// </summary>
/// <param name="path">The path.</param> /// <param name="path">The path.</param>
/// <param name="separatorCharacter">The separator character.</param> /// <param name="separatorCharacter">The separator character.</param>
/// <returns></returns> /// <returns></returns>
public static string EndPath(string path, char separatorCharacter) public static string EndPath(string path, char separatorCharacter)
{ {
if(path == null || path == "" || path.Length < 1) if(path == null || path == "" || path.Length < 1)
{ {
return ""; return "";
} }
if(!path.EndsWith(separatorCharacter.ToString())) if(!path.EndsWith(separatorCharacter.ToString()))
{ {
return (path + separatorCharacter); return (path + separatorCharacter);
} }
return path; return path;
} }
/// <summary> /// <summary>
/// Ends the path. /// Ends the path.
/// </summary> /// </summary>
/// <param name="path">The path.</param> /// <param name="path">The path.</param>
/// <returns></returns> /// <returns></returns>
public static string EndPath(string path) public static string EndPath(string path)
{ {
return EndPath(path, Path.DirectorySeparatorChar); return EndPath(path, Path.DirectorySeparatorChar);
} }
/// <summary> /// <summary>
/// Makes the file path. /// Makes the file path.
/// </summary> /// </summary>
/// <param name="path">The path.</param> /// <param name="path">The path.</param>
/// <param name="name">The name.</param> /// <param name="name">The name.</param>
/// <param name="ext">The ext.</param> /// <param name="ext">The ext.</param>
/// <returns></returns> /// <returns></returns>
public static string MakeFilePath(string path, string name, string ext) public static string MakeFilePath(string path, string name, string ext)
{ {
string ret = EndPath(NormalizePath(path)); string ret = EndPath(NormalizePath(path));
if( name == null ) if( name == null )
{ {
throw new ArgumentNullException("name"); throw new ArgumentNullException("name");
} }
ret += name; ret += name;
if(!name.EndsWith("." + ext)) if(!name.EndsWith("." + ext))
{ {
ret += "." + ext; ret += "." + ext;
} }
//foreach(char c in Path.GetInvalidPathChars()) //foreach(char c in Path.GetInvalidPathChars())
//{ //{
// ret = ret.Replace(c, '_'); // ret = ret.Replace(c, '_');
//} //}
return ret; return ret;
} }
/// <summary> /// <summary>
/// Makes the file path. /// Makes the file path.
/// </summary> /// </summary>
/// <param name="path">The path.</param> /// <param name="path">The path.</param>
/// <param name="name">The name.</param> /// <param name="name">The name.</param>
/// <returns></returns> /// <returns></returns>
public static string MakeFilePath(string path, string name) public static string MakeFilePath(string path, string name)
{ {
string ret = EndPath(NormalizePath(path)); string ret = EndPath(NormalizePath(path));
if( name == null ) if( name == null )
{ {
throw new ArgumentNullException("name"); throw new ArgumentNullException("name");
} }
ret += name; ret += name;
//foreach (char c in Path.GetInvalidPathChars()) //foreach (char c in Path.GetInvalidPathChars())
//{ //{
// ret = ret.Replace(c, '_'); // ret = ret.Replace(c, '_');
//} //}
return ret; return ret;
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
/// <param name="path"></param> /// <param name="path"></param>
/// <returns></returns> /// <returns></returns>
public static string MakeReferencePath(string path) public static string MakeReferencePath(string path)
{ {
string ret = EndPath(NormalizePath(path)); string ret = EndPath(NormalizePath(path));
//foreach (char c in Path.GetInvalidPathChars()) //foreach (char c in Path.GetInvalidPathChars())
//{ //{
// ret = ret.Replace(c, '_'); // ret = ret.Replace(c, '_');
//} //}
return ret; return ret;
} }
/// <summary> /// <summary>
/// Sets the current dir. /// Sets the current dir.
/// </summary> /// </summary>
/// <param name="path">The path.</param> /// <param name="path">The path.</param>
public static void SetCurrentDir(string path) public static void SetCurrentDir(string path)
{ {
if( path == null ) if( path == null )
{ {
throw new ArgumentNullException("path"); throw new ArgumentNullException("path");
} }
if(path.Length < 1) if(path.Length < 1)
{ {
return; return;
} }
Environment.CurrentDirectory = path; Environment.CurrentDirectory = path;
} }
/// <summary> /// <summary>
/// Checks the type. /// Checks the type.
/// </summary> /// </summary>
/// <param name="typeToCheck">The type to check.</param> /// <param name="typeToCheck">The type to check.</param>
/// <param name="attr">The attr.</param> /// <param name="attr">The attr.</param>
/// <param name="inter">The inter.</param> /// <param name="inter">The inter.</param>
/// <returns></returns> /// <returns></returns>
public static object CheckType(Type typeToCheck, Type attr, Type inter) public static object CheckType(Type typeToCheck, Type attr, Type inter)
{ {
if(typeToCheck == null || attr == null) if(typeToCheck == null || attr == null)
{ {
return null; return null;
} }
object[] attrs = typeToCheck.GetCustomAttributes(attr, false); object[] attrs = typeToCheck.GetCustomAttributes(attr, false);
if(attrs == null || attrs.Length < 1) if(attrs == null || attrs.Length < 1)
{ {
return null; return null;
} }
if( inter == null ) if( inter == null )
{ {
throw new ArgumentNullException("inter"); throw new ArgumentNullException("inter");
} }
if(typeToCheck.GetInterface(inter.FullName) == null) if(typeToCheck.GetInterface(inter.FullName) == null)
{ {
return null; return null;
} }
return attrs[0]; return attrs[0];
} }
/// <summary> /// <summary>
/// Attributes the value. /// Attributes the value.
/// </summary> /// </summary>
/// <param name="node">The node.</param> /// <param name="node">The node.</param>
/// <param name="attr">The attr.</param> /// <param name="attr">The attr.</param>
/// <param name="def">The def.</param> /// <param name="def">The def.</param>
/// <returns></returns> /// <returns></returns>
public static string AttributeValue(XmlNode node, string attr, string def) public static string AttributeValue(XmlNode node, string attr, string def)
{ {
if( node == null ) if( node == null )
{ {
throw new ArgumentNullException("node"); throw new ArgumentNullException("node");
} }
if(node.Attributes[attr] == null) if(node.Attributes[attr] == null)
{ {
return def; return def;
} }
string val = node.Attributes[attr].Value; string val = node.Attributes[attr].Value;
if(!CheckForOSVariables) if(!CheckForOSVariables)
{ {
return val; return val;
} }
return InterpolateForEnvironmentVariables(val); return InterpolateForEnvironmentVariables(val);
} }
/// <summary> /// <summary>
/// Parses the boolean. /// Parses the boolean.
/// </summary> /// </summary>
/// <param name="node">The node.</param> /// <param name="node">The node.</param>
/// <param name="attr">The attr.</param> /// <param name="attr">The attr.</param>
/// <param name="defaultValue">if set to <c>true</c> [default value].</param> /// <param name="defaultValue">if set to <c>true</c> [default value].</param>
/// <returns></returns> /// <returns></returns>
public static bool ParseBoolean(XmlNode node, string attr, bool defaultValue) public static bool ParseBoolean(XmlNode node, string attr, bool defaultValue)
{ {
if( node == null ) if( node == null )
{ {
throw new ArgumentNullException("node"); throw new ArgumentNullException("node");
} }
if(node.Attributes[attr] == null) if(node.Attributes[attr] == null)
{ {
return defaultValue; return defaultValue;
} }
return bool.Parse(node.Attributes[attr].Value); return bool.Parse(node.Attributes[attr].Value);
} }
/// <summary> /// <summary>
/// Enums the attribute value. /// Enums the attribute value.
/// </summary> /// </summary>
/// <param name="node">The node.</param> /// <param name="node">The node.</param>
/// <param name="attr">The attr.</param> /// <param name="attr">The attr.</param>
/// <param name="enumType">Type of the enum.</param> /// <param name="enumType">Type of the enum.</param>
/// <param name="def">The def.</param> /// <param name="def">The def.</param>
/// <returns></returns> /// <returns></returns>
public static object EnumAttributeValue(XmlNode node, string attr, Type enumType, object def) public static object EnumAttributeValue(XmlNode node, string attr, Type enumType, object def)
{ {
if( def == null ) if( def == null )
{ {
throw new ArgumentNullException("def"); throw new ArgumentNullException("def");
} }
string val = AttributeValue(node, attr, def.ToString()); string val = AttributeValue(node, attr, def.ToString());
return Enum.Parse(enumType, val, true); return Enum.Parse(enumType, val, true);
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
/// <param name="assemblyName"></param> /// <param name="assemblyName"></param>
/// <param name="projectType"></param> /// <param name="projectType"></param>
/// <returns></returns> /// <returns></returns>
public static string AssemblyFullName(string assemblyName, ProjectType projectType) public static string AssemblyFullName(string assemblyName, ProjectType projectType)
{ {
return assemblyName + (projectType == ProjectType.Library ? ".dll" : ".exe"); return assemblyName + (projectType == ProjectType.Library ? ".dll" : ".exe");
} }
#endregion #endregion
} }
} }

414
Prebuild/src/Core/Utilities/Log.cs
View File

@ -28,74 +28,74 @@ using System.IO;
namespace Prebuild.Core.Utilities namespace Prebuild.Core.Utilities
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public enum LogType public enum LogType
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
None, None,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
Info, Info,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
Warning, Warning,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
Error Error
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[Flags] [Flags]
public enum LogTargets public enum LogTargets
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
None = 0, None = 0,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
Null = 1, Null = 1,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
File = 2, File = 2,
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
Console = 4 Console = 4
} }
/// <summary> /// <summary>
/// Summary description for Log. /// Summary description for Log.
/// </summary> /// </summary>
public class Log : IDisposable public class Log : IDisposable
{ {
#region Fields #region Fields
private TextWriter m_Writer; private TextWriter m_Writer;
private LogTargets m_Target = LogTargets.Null; private LogTargets m_Target = LogTargets.Null;
bool disposed; bool disposed;
#endregion #endregion
#region Constructors #region Constructors
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="Log"/> class. /// Initializes a new instance of the <see cref="Log"/> class.
/// </summary> /// </summary>
/// <param name="target">The target.</param> /// <param name="target">The target.</param>
/// <param name="fileName">Name of the file.</param> /// <param name="fileName">Name of the file.</param>
public Log(LogTargets target, string fileName) public Log(LogTargets target, string fileName)
{ {
m_Target = target; m_Target = target;
@ -111,166 +111,166 @@ namespace Prebuild.Core.Utilities
} }
} }
#endregion #endregion
#region Public Methods #region Public Methods
/// <summary> /// <summary>
/// Writes this instance. /// Writes this instance.
/// </summary> /// </summary>
public void Write() public void Write()
{ {
Write(string.Empty); Write(string.Empty);
} }
/// <summary> /// <summary>
/// Writes the specified MSG. /// Writes the specified MSG.
/// </summary> /// </summary>
/// <param name="msg">The MSG.</param> /// <param name="msg">The MSG.</param>
public void Write(string msg) public void Write(string msg)
{ {
if((m_Target & LogTargets.Null) != 0) if((m_Target & LogTargets.Null) != 0)
{ {
return; return;
} }
if((m_Target & LogTargets.Console) != 0) if((m_Target & LogTargets.Console) != 0)
{ {
Console.WriteLine(msg); Console.WriteLine(msg);
} }
if((m_Target & LogTargets.File) != 0 && m_Writer != null) if((m_Target & LogTargets.File) != 0 && m_Writer != null)
{ {
m_Writer.WriteLine(msg); m_Writer.WriteLine(msg);
} }
} }
/// <summary> /// <summary>
/// Writes the specified format. /// Writes the specified format.
/// </summary> /// </summary>
/// <param name="format">The format.</param> /// <param name="format">The format.</param>
/// <param name="args">The args.</param> /// <param name="args">The args.</param>
public void Write(string format, params object[] args) public void Write(string format, params object[] args)
{ {
Write(string.Format(format,args)); Write(string.Format(format,args));
} }
/// <summary> /// <summary>
/// Writes the specified type. /// Writes the specified type.
/// </summary> /// </summary>
/// <param name="type">The type.</param> /// <param name="type">The type.</param>
/// <param name="format">The format.</param> /// <param name="format">The format.</param>
/// <param name="args">The args.</param> /// <param name="args">The args.</param>
public void Write(LogType type, string format, params object[] args) public void Write(LogType type, string format, params object[] args)
{ {
if((m_Target & LogTargets.Null) != 0) if((m_Target & LogTargets.Null) != 0)
{ {
return; return;
} }
string str = ""; string str = "";
switch(type) switch(type)
{ {
case LogType.Info: case LogType.Info:
str = "[I] "; str = "[I] ";
break; break;
case LogType.Warning: case LogType.Warning:
str = "[!] "; str = "[!] ";
break; break;
case LogType.Error: case LogType.Error:
str = "[X] "; str = "[X] ";
break; break;
} }
Write(str + format,args); Write(str + format,args);
} }
/// <summary> /// <summary>
/// Writes the exception. /// Writes the exception.
/// </summary> /// </summary>
/// <param name="type">The type.</param> /// <param name="type">The type.</param>
/// <param name="ex">The ex.</param> /// <param name="ex">The ex.</param>
public void WriteException(LogType type, Exception ex) public void WriteException(LogType type, Exception ex)
{ {
if(ex != null) if(ex != null)
{ {
Write(type, ex.Message); Write(type, ex.Message);
//#if DEBUG //#if DEBUG
m_Writer.WriteLine("Exception @{0} stack trace [[", ex.TargetSite.Name); m_Writer.WriteLine("Exception @{0} stack trace [[", ex.TargetSite.Name);
m_Writer.WriteLine(ex.StackTrace); m_Writer.WriteLine(ex.StackTrace);
m_Writer.WriteLine("]]"); m_Writer.WriteLine("]]");
//#endif //#endif
} }
} }
/// <summary> /// <summary>
/// Flushes this instance. /// Flushes this instance.
/// </summary> /// </summary>
public void Flush() public void Flush()
{ {
if(m_Writer != null) if(m_Writer != null)
{ {
m_Writer.Flush(); m_Writer.Flush();
} }
} }
#endregion #endregion
#region IDisposable Members #region IDisposable Members
/// <summary> /// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or /// Performs application-defined tasks associated with freeing, releasing, or
/// resetting unmanaged resources. /// resetting unmanaged resources.
/// </summary> /// </summary>
public void Dispose() public void Dispose()
{ {
Dispose(true); Dispose(true);
GC.SuppressFinalize(this); GC.SuppressFinalize(this);
} }
/// <summary> /// <summary>
/// Dispose objects /// Dispose objects
/// </summary> /// </summary>
/// <param name="disposing"> /// <param name="disposing">
/// If true, it will dispose close the handle /// If true, it will dispose close the handle
/// </param> /// </param>
/// <remarks> /// <remarks>
/// Will dispose managed and unmanaged resources. /// Will dispose managed and unmanaged resources.
/// </remarks> /// </remarks>
protected virtual void Dispose(bool disposing) protected virtual void Dispose(bool disposing)
{ {
if (!this.disposed) if (!this.disposed)
{ {
if (disposing) if (disposing)
{ {
if (m_Writer != null) if (m_Writer != null)
{ {
m_Writer.Close(); m_Writer.Close();
m_Writer = null; m_Writer = null;
} }
} }
} }
this.disposed = true; this.disposed = true;
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
~Log() ~Log()
{ {
this.Dispose(false); this.Dispose(false);
} }
/// <summary> /// <summary>
/// Closes and destroys this object /// Closes and destroys this object
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Same as Dispose(true) /// Same as Dispose(true)
/// </remarks> /// </remarks>
public void Close() public void Close()
{ {
Dispose(); Dispose();
} }
#endregion #endregion
} }
} }

94
Prebuild/src/Core/WarningException.cs
View File

@ -28,57 +28,57 @@ using System.Runtime.Serialization;
namespace Prebuild.Core namespace Prebuild.Core
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
[Serializable] [Serializable]
public class WarningException : Exception public class WarningException : Exception
{ {
#region Constructors #region Constructors
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
public WarningException() public WarningException()
{ {
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
/// <param name="format"></param> /// <param name="format"></param>
/// <param name="args"></param> /// <param name="args"></param>
public WarningException(string format, params object[] args) public WarningException(string format, params object[] args)
: base(String.Format(format, args)) : base(String.Format(format, args))
{ {
} }
/// <summary> /// <summary>
/// Exception with specified string /// Exception with specified string
/// </summary> /// </summary>
/// <param name="message">Exception message</param> /// <param name="message">Exception message</param>
public WarningException(string message): base(message) public WarningException(string message): base(message)
{ {
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
/// <param name="message"></param> /// <param name="message"></param>
/// <param name="exception"></param> /// <param name="exception"></param>
public WarningException(string message, Exception exception) : base(message, exception) public WarningException(string message, Exception exception) : base(message, exception)
{ {
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
/// <param name="info"></param> /// <param name="info"></param>
/// <param name="context"></param> /// <param name="context"></param>
protected WarningException(SerializationInfo info, StreamingContext context) : base( info, context ) protected WarningException(SerializationInfo info, StreamingContext context) : base( info, context )
{ {
} }
#endregion #endregion
} }
} }

194
Prebuild/src/Prebuild.cs
View File

@ -44,48 +44,48 @@ using Prebuild.Core.Utilities;
namespace Prebuild namespace Prebuild
{ {
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
class Prebuild class Prebuild
{ {
#region Main #region Main
[STAThread] [STAThread]
static void Main(string[] args) static void Main(string[] args)
{ {
Kernel kernel = null; Kernel kernel = null;
try try
{ {
kernel = Kernel.Instance; kernel = Kernel.Instance;
kernel.Initialize(LogTargets.File | LogTargets.Console, args); kernel.Initialize(LogTargets.File | LogTargets.Console, args);
bool exit = false; bool exit = false;
if(kernel.CommandLine.WasPassed("usage")) if(kernel.CommandLine.WasPassed("usage"))
{ {
exit = true; exit = true;
OutputUsage(); OutputUsage();
} }
if(kernel.CommandLine.WasPassed("showtargets")) if(kernel.CommandLine.WasPassed("showtargets"))
{ {
exit = true; exit = true;
OutputTargets(kernel); OutputTargets(kernel);
} }
if(kernel.CommandLine.WasPassed("install")) if(kernel.CommandLine.WasPassed("install"))
{ {
exit = true; exit = true;
InstallAssembly(kernel); InstallAssembly(kernel);
} }
if(kernel.CommandLine.WasPassed("remove")) if(kernel.CommandLine.WasPassed("remove"))
{ {
exit = true; exit = true;
RemoveAssembly(kernel); RemoveAssembly(kernel);
} }
if(!exit) if(!exit)
{ {
kernel.Process(); kernel.Process();
} }
} }
#if !DEBUG #if !DEBUG
catch (Exception ex) catch (Exception ex)
@ -96,70 +96,70 @@ namespace Prebuild
#endif #endif
finally finally
{ {
if(kernel != null && kernel.PauseAfterFinish) if(kernel != null && kernel.PauseAfterFinish)
{ {
Console.WriteLine("\nPress enter to continue..."); Console.WriteLine("\nPress enter to continue...");
Console.ReadLine(); Console.ReadLine();
} }
} }
} }
#endregion #endregion
#region Private Methods #region Private Methods
private static void InstallAssembly(Kernel kernel) private static void InstallAssembly(Kernel kernel)
{ {
Publish publish = new Publish(); Publish publish = new Publish();
string file = kernel.CommandLine["install"]; string file = kernel.CommandLine["install"];
//Console.WriteLine(".."+file+".."); //Console.WriteLine(".."+file+"..");
publish.GacInstall(file); publish.GacInstall(file);
} }
private static void RemoveAssembly(Kernel kernel) private static void RemoveAssembly(Kernel kernel)
{ {
Publish publish = new Publish(); Publish publish = new Publish();
string file = kernel.CommandLine["remove"]; string file = kernel.CommandLine["remove"];
publish.GacRemove(file); publish.GacRemove(file);
} }
private static void OutputUsage() private static void OutputUsage()
{ {
Console.WriteLine("Usage: prebuild /target <target> [options]"); Console.WriteLine("Usage: prebuild /target <target> [options]");
Console.WriteLine("Available command-line switches:"); Console.WriteLine("Available command-line switches:");
Console.WriteLine(); Console.WriteLine();
Console.WriteLine("/target Target for Prebuild"); Console.WriteLine("/target Target for Prebuild");
Console.WriteLine("/clean Clean the build files for the given target"); Console.WriteLine("/clean Clean the build files for the given target");
Console.WriteLine("/file XML file to process"); Console.WriteLine("/file XML file to process");
Console.WriteLine("/log Log file to write to"); Console.WriteLine("/log Log file to write to");
Console.WriteLine("/ppo Pre-process the file, but perform no other processing"); Console.WriteLine("/ppo Pre-process the file, but perform no other processing");
Console.WriteLine("/pause Pauses the application after execution to view the output"); Console.WriteLine("/pause Pauses the application after execution to view the output");
Console.WriteLine("/yes Default to yes to any questions asked"); Console.WriteLine("/yes Default to yes to any questions asked");
Console.WriteLine("/install Install assembly into the GAC"); Console.WriteLine("/install Install assembly into the GAC");
Console.WriteLine("/remove Remove assembly from the GAC"); Console.WriteLine("/remove Remove assembly from the GAC");
Console.WriteLine(); Console.WriteLine();
Console.WriteLine("See 'prebuild /showtargets for a list of available targets"); Console.WriteLine("See 'prebuild /showtargets for a list of available targets");
Console.WriteLine("See readme.txt or check out http://dnpb.sourceforge.net for more information"); Console.WriteLine("See readme.txt or check out http://dnpb.sourceforge.net for more information");
Console.WriteLine(); Console.WriteLine();
} }
private static void OutputTargets(Kernel kern) private static void OutputTargets(Kernel kern)
{ {
Console.WriteLine("Targets available in Prebuild:"); Console.WriteLine("Targets available in Prebuild:");
Console.WriteLine(""); Console.WriteLine("");
if(kern.Targets.Keys.Count > 0) if(kern.Targets.Keys.Count > 0)
{ {
string[] targs = new string[kern.Targets.Keys.Count]; string[] targs = new string[kern.Targets.Keys.Count];
kern.Targets.Keys.CopyTo(targs, 0); kern.Targets.Keys.CopyTo(targs, 0);
Array.Sort(targs); Array.Sort(targs);
foreach(string target in targs) foreach(string target in targs)
{ {
Console.WriteLine(target); Console.WriteLine(target);
} }
} }
Console.WriteLine(""); Console.WriteLine("");
} }
#endregion #endregion
} }
} }

7
Prebuild/src/Properties/AssemblyInfo.cs
View File

@ -61,17 +61,18 @@ using System.Resources;
[assembly: AssemblyConfiguration(".NET CLR")] [assembly: AssemblyConfiguration(".NET CLR")]
[assembly: AssemblyCompany("The Prebuild Project")] [assembly: AssemblyCompany("The Prebuild Project")]
[assembly: AssemblyProduct("")] [assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("Copyright 2004-2013 " + [assembly: AssemblyCopyright("Copyright 2004-2015 " +
"Matthew Holmes, " + "Matthew Holmes, " +
"Dan Moorehead, " + "Dan Moorehead, " +
"C.J. Adams-Collier, " + "C.J. Adams-Collier, " +
"Rob Loach, " + "Rob Loach, " +
"David Hudson," + "David Hudson," +
"John Hurliman")] "John Hurliman" +
"WhiteCore Development")]
[assembly: AssemblyTrademark("")] [assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")] [assembly: AssemblyCulture("")]
[assembly: NeutralResourcesLanguageAttribute("en-US")] [assembly: NeutralResourcesLanguageAttribute("en-US")]
[assembly: AssemblyVersion("2.0.6.*")] [assembly: AssemblyVersion("2.0.7.*")]
// //
// Version information for an assembly consists of the following four values: // Version information for an assembly consists of the following four values:

BIN
bin/Prebuild.exe
View File

Binary file not shown.